Support invocation inference across narrowing reference conversions

src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java

@@ -1565,7 +1565,7 @@ private void addBindings2Scope(JCStatement introducingStatement,
     }
 
     public void visitEnhancedVariableDeclaration(JCEnhancedVariableDeclaration tree) {
-        attribExpr(tree.expr, env);
+        attribExpr(tree.expr, env, patternTarget(tree.pattern));
         attribExpr(tree.pattern, env, tree.expr.type);
 
         matchBindings.bindingsWhenTrue.forEach(env.info.scope::enter);
@@ -4306,7 +4306,8 @@ public void visitRecordPattern(JCRecordPattern tree) {
             tree.record = syms.errSymbol;
             site = tree.type = types.createErrorType(tree.record.type);
         } else {
-            Type type = attribType(tree.deconstructor, env);
+            Type type = tree.deconstructor.type != null ?
+                    tree.deconstructor.type : attribType(tree.deconstructor, env);
             if (type.isRaw() && type.tsym.getTypeParameters().nonEmpty()) {
                 Type inferred = infer.instantiatePatternType(resultInfo.pt, type.tsym);
                 if (inferred == null) {
@@ -5649,6 +5650,22 @@ public void visitModuleDef(JCModuleDecl tree) {
         }
     }
 
+    private Type patternTarget(JCTree pattern) {
+        if (pattern instanceof JCRecordPattern record) {
+            if (record.deconstructor.hasTag(VARTYPE)) {
+                return Type.noType;
+            }
+            Type recordType = record.deconstructor.type != null ?
+                    record.deconstructor.type : attribType(record.deconstructor, env);
+            if (recordType.hasTag(ERROR) ||
+                    recordType.isRaw() && recordType.tsym.getTypeParameters().nonEmpty()) {
+                return Type.noType;
+            }
+            return recordType;
+        }
+        return Type.noType;
+    }
+
     /** Finish the attribution of a class. */
     private void attribClassBody(Env<AttrContext> env, ClassSymbol c) {
         JCClassDecl tree = (JCClassDecl)env.tree;

src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java

@@ -394,7 +394,8 @@ Type generateReturnConstraints(JCTree tree, Attr.ResultInfo resultInfo,
             }
         }
         Type qtype = inferenceContext.asUndetVar(from);
-        Type to = resultInfo.pt;
+        Type to = resultCompatibilityTarget(mt.getReturnType(), resultInfo.pt,
+                inferenceContext, rsInfoInfContext);
 
         if (qtype.hasTag(VOID)) {
             to = syms.voidType;
@@ -416,6 +417,33 @@ Type generateReturnConstraints(JCTree tree, Attr.ResultInfo resultInfo,
         return from;
     }
 
+    /**
+     * Returns the target for invocation result constraints, lifting a proper
+     * target to the supertype corresponding to the generic return type. Targets
+     * free in an enclosing inference context are left unchanged.
+     */
+    private Type resultCompatibilityTarget(Type returnType, Type targetType,
+            InferenceContext inferenceContext, InferenceContext targetInferenceContext) {
+        if (returnType.hasTag(CLASS) &&
+                returnType.getTypeArguments().stream()
+                        .anyMatch(t -> t.containsAny(inferenceContext.inferencevars)) &&
+                !targetType.hasTag(NONE) &&
+                !targetType.hasTag(ERROR) &&
+                targetType.isReference() &&
+                !targetInferenceContext.free(targetType) &&
+                types.isSubtype(types.erasure(targetType), types.erasure(returnType))) {
+            Type liftedTarget = lift(targetType, returnType);
+            if (liftedTarget != null) {
+                return liftedTarget;
+            }
+        }
+        return targetType;
+    }
+
+    private Type lift(Type targetType, Type returnType) {
+        return types.asSuper(targetType, returnType.tsym);
+    }
+
     private boolean needsEagerInstantiation(UndetVar from, Type to, InferenceContext inferenceContext) {
         if (to.isPrimitive()) {
             /* T is a primitive type, and one of the primitive wrapper classes is an instantiation,

test/langtools/jdk/jshell/EnhancedVariableDeclarationsTest.java

@@ -165,9 +165,9 @@ public void testInferredPatternsNonExhaustive() {
         assertEval("interface IBox {}");
         assertEval("record BoxImpl(int x) implements IBox {}");
 
-        assertDeclareFail("Pair(var x, var y) = new Object();", "compiler.err.enhanced.local.variable.declaration.not.exhaustive.on.type");
+        assertDeclareFail("Pair(var x, var y) = new Object();", "compiler.err.prob.found.req");
         assertDeclareFail("Box(var value) = new Object();", "compiler.err.enhanced.local.variable.declaration.not.exhaustive.on.type");
-        assertDeclareFail("BoxImpl(var x) = (IBox) new BoxImpl(1);", "compiler.err.enhanced.local.variable.declaration.not.exhaustive.on.type");
+        assertDeclareFail("BoxImpl(var x) = (IBox) new BoxImpl(1);", "compiler.err.prob.found.req");
         assertDeclareFail("Holder(Point(var x)) = new Holder(new Point(1));", "compiler.err.enhanced.local.variable.declaration.not.exhaustive.on.type");
     }
 

test/langtools/tools/javac/diags/examples/EnhancedLocalVariableDeclarationNotExhaustiveOnType.java

@@ -27,9 +27,10 @@
 // options: --enable-preview -source ${jdk.version}
 
 class EnhancedLocalVariableDeclarationNotExhaustiveOnType {
-    void m(Object o) {
-        Point(var x) = o;
+    void m() {
+        Holder(Point(var x)) = new Holder(new Point(1));
     }
 
     record Point(int x) {}
+    record Holder(Object value) {}
 }