8359370: [lworld] allow instance fields of identity classes to be readable in the prologue phase

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

@@ -124,6 +124,7 @@ public class Attr extends JCTree.Visitor {
     final ArgumentAttr argumentAttr;
     final MatchBindingsComputer matchBindingsComputer;
     final AttrRecover attrRecover;
+    final LocalProxyVarsGen localProxyVarsGen;
 
     public static Attr instance(Context context) {
         Attr instance = context.get(attrKey);
@@ -163,6 +164,7 @@ protected Attr(Context context) {
         argumentAttr = ArgumentAttr.instance(context);
         matchBindingsComputer = MatchBindingsComputer.instance(context);
         attrRecover = AttrRecover.instance(context);
+        localProxyVarsGen = LocalProxyVarsGen.instance(context);
 
         Options options = Options.instance(context);
 
@@ -317,20 +319,14 @@ void checkAssignable(DiagnosticPosition pos, VarSymbol v, JCTree base, Env<AttrC
             return;
         }
 
-        // Check instance field assignments that appear in constructor prologues
+        // Check instance field assignments that appear in constructor prologues, like: `this.field = value;`
         if (rs.isEarlyReference(env, base, v)) {
 
             // Field may not be inherited from a superclass
             if (v.owner != env.enclClass.sym) {
                 log.error(pos, Errors.CantRefBeforeCtorCalled(v));
                 return;
             }
-
-            // Field may not have an initializer
-            if ((v.flags() & HASINIT) != 0) {
-                log.error(pos, Errors.CantAssignInitializedBeforeCtorCalled(v));
-                return;
-            }
         }
     }
 
@@ -4391,7 +4387,31 @@ public void visitIdent(JCIdent tree) {
         }
 
         result = checkId(tree, env1.enclClass.sym.type, sym, env, resultInfo);
+        checkIfAllowedInPrologue(tree);
     }
+    // where
+        void checkIfAllowedInPrologue(JCTree tree) {
+            Assert.check(tree.hasTag(IDENT) || tree.hasTag(SELECT));
+            Symbol sym = TreeInfo.symbolFor(tree);
+            if (env.info.ctorPrologue && allowValueClasses) {
+                JCFieldAccess enclosingSelect = rs.new FindEnclosingSelect().scan(tree, env.tree);
+                if (enclosingSelect == null) { // this tree is standalone, not part of a more complex name
+                    if (localProxyVarsGen.hasAST(env.enclMethod, tree)) {
+                        if (sym.owner != env.enclClass.sym ||
+                            TreeInfo.isExplicitThisOrSuperReference(types, (ClassType)env.enclClass.type, tree)) {
+                            /* in this case we are seeing something like `super.field` or accessing a field of a
+                             * super class while in the prologue of a subclass, at Resolve javac just didn't have enough
+                             * information to determine this
+                             */
+                            localProxyVarsGen.removeASTReadInPrologue(env.enclMethod, tree);
+                            log.error(tree, Errors.CantRefBeforeCtorCalled(sym));
+                        } else if (!sym.isFinal() && !sym.isStrict()) {
+                            localProxyVarsGen.removeASTReadInPrologue(env.enclMethod, tree);
+                        }
+                    }
+                }
+            }
+        }
 
     public void visitSelect(JCFieldAccess tree) {
         // Determine the expected kind of the qualifier expression.
@@ -4527,6 +4547,7 @@ public void visitSelect(JCFieldAccess tree) {
 
         env.info.selectSuper = selectSuperPrev;
         result = checkId(tree, site, sym, env, resultInfo);
+        checkIfAllowedInPrologue(tree);
     }
     //where
         /** Determine symbol referenced by a Select expression,

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

@@ -63,7 +63,7 @@ public enum CompileState {
         TRANSPATTERNS(8),
         LOWER(9),
         UNLAMBDA(10),
-        STRICT_FIELDS_PROXIES(11),
+        FIELDS_PROXIES(11),
         GENERATE(12);
 
         CompileState(int value) {

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

@@ -487,15 +487,21 @@ protected void scanSyntheticBreak(TreeMaker make, JCTree swtch) {
 
         // Do something with static or non-static field initializers and initialization blocks.
         protected void forEachInitializer(JCClassDecl classDef, boolean isStatic, Consumer<? super JCTree> handler) {
-            forEachInitializer(classDef, isStatic, false, handler);
+            forEachInitializer(classDef, isStatic, InitializerDisc.PROCESS_ALL, handler);
+        }
+
+        enum InitializerDisc {
+            PROCESS_ALL,
+            EARLY_ONLY,
+            LATE_ONLY
         }
 
         /* Do something with static or non-static field initializers and initialization blocks.
-         * the `earlyOnly` argument will determine if we will deal or not with early variable instance
+         * the `discriminator` argument will determine if we will deal or not with early variable instance
          * initializers we want to process only those before a super() invocation and ignore them after
          * it.
          */
-        protected void forEachInitializer(JCClassDecl classDef, boolean isStatic, boolean earlyOnly,
+        protected void forEachInitializer(JCClassDecl classDef, boolean isStatic, InitializerDisc discriminator,
                                           Consumer<? super JCTree> handler) {
             if (classDef == initScanClass)          // avoid infinite loops
                 return;
@@ -515,15 +521,18 @@ protected void forEachInitializer(JCClassDecl classDef, boolean isStatic, boolea
                      */
                     boolean isDefStatic = ((TreeInfo.flags(def) | (TreeInfo.symbolFor(def) == null ? 0 : TreeInfo.symbolFor(def).flags_field)) & STATIC) != 0;
                     if (!def.hasTag(METHODDEF) && (isDefStatic == isStatic)) {
-                        if (def instanceof JCVariableDecl varDecl) {
-                            boolean isEarly = varDecl.init != null &&
-                                    varDecl.sym.isStrict() &&
-                                    !varDecl.sym.isStatic();
-                            if (isEarly == earlyOnly) {
+                        if (discriminator == InitializerDisc.PROCESS_ALL) {
+                            handler.accept(def);
+                        } else {
+                            if (def instanceof JCVariableDecl varDecl) {
+                                boolean isEarly = varDecl.init != null &&
+                                        !varDecl.sym.isStatic();
+                                if (isEarly && discriminator == InitializerDisc.EARLY_ONLY) {
+                                    handler.accept(def);
+                                }
+                            } else if (discriminator == InitializerDisc.LATE_ONLY) {
                                 handler.accept(def);
                             }
-                        } else if (!earlyOnly) {
-                            handler.accept(def);
                         }
                     }
                 }
@@ -2221,13 +2230,17 @@ protected boolean trackable(VarSymbol sym) {
             return
                 sym.pos >= startPos &&
                 ((sym.owner.kind == MTH || sym.owner.kind == VAR ||
-                isFinalOrStrictUninitializedField(sym)));
+                isTrackableField(sym)));
         }
 
-        boolean isFinalOrStrictUninitializedField(VarSymbol sym) {
+        /* we want to track fields that are:
+         *     - final regardless of "staticness"
+         *     - non-final instance fields that lack an initializer
+         */
+        boolean isTrackableField(VarSymbol sym) {
             return sym.owner.kind == TYP &&
                    (((sym.flags() & (FINAL | HASINIT | PARAMETER)) == FINAL ||
-                     (sym.flags() & (STRICT | HASINIT | PARAMETER)) == STRICT) &&
+                   (sym.flags() & (STRICT | HASINIT | PARAMETER)) == STRICT) &&
                    classDef.sym.isEnclosedBy((ClassSymbol)sym.owner));
         }
 
@@ -2560,15 +2573,18 @@ public void visitMethodDef(JCMethodDecl tree) {
                     scan(tree.body);
 
                     if (isConstructor) {
-                        boolean isSynthesized = (tree.sym.flags() &
-                                                 GENERATEDCONSTR) != 0;
+                        boolean isAGeneratedConstructor = (tree.sym.flags() & GENERATEDCONSTR) != 0;
                         for (int i = firstadr; i < nextadr; i++) {
                             JCVariableDecl vardecl = vardecls[i];
                             VarSymbol var = vardecl.sym;
                             if (var.owner == classDef.sym && !var.isStatic()) {
+                                // ignore non-final instance fields
+                                if (allowValueClasses && var.owner.kind == TYP && !var.isFinal()) {
+                                    continue;
+                                }
                                 // choose the diagnostic position based on whether
-                                // the ctor is default(synthesized) or not
-                                if (isSynthesized && !isCompactOrGeneratedRecordConstructor) {
+                                // the ctor is default(generated) or not
+                                if (isAGeneratedConstructor && !isCompactOrGeneratedRecordConstructor) {
                                     checkInit(TreeInfo.diagnosticPositionFor(var, vardecl),
                                             var, Errors.VarNotInitializedInDefaultConstructor(var));
                                 } else if (isCompactOrGeneratedRecordConstructor) {
@@ -3086,7 +3102,7 @@ public void visitApply(JCMethodInvocation tree) {
             Name name = TreeInfo.name(tree.meth);
             // let's process early initializers
             if (name == names._super) {
-                forEachInitializer(classDef, false, true, def -> {
+                forEachInitializer(classDef, false, InitializerDisc.EARLY_ONLY, def -> {
                     scan(def);
                     clearPendingExits(false);
                 });
@@ -3108,7 +3124,7 @@ public void visitApply(JCMethodInvocation tree) {
                             checkInit(TreeInfo.diagEndPos(tree), var, Errors.StrictFieldNotHaveBeenInitializedBeforeSuper(var));
                         }
                     }
-                    forEachInitializer(classDef, false, def -> {
+                    forEachInitializer(classDef, false, InitializerDisc.LATE_ONLY, def -> {
                         scan(def);
                         clearPendingExits(false);
                     });
@@ -3118,7 +3134,7 @@ public void visitApply(JCMethodInvocation tree) {
                 else if (name == names._this) {
                     for (int address = firstadr; address < nextadr; address++) {
                         VarSymbol sym = vardecls[address].sym;
-                        if (isFinalOrStrictUninitializedField(sym) && !sym.isStatic())
+                        if (isTrackableField(sym) && !sym.isStatic())
                             letInit(tree.pos(), sym);
                     }
                 }
@@ -3199,9 +3215,10 @@ public void visitAssign(JCAssign tree) {
         // assigned before reading their value
         public void visitSelect(JCFieldAccess tree) {
             super.visitSelect(tree);
-            if (TreeInfo.isThisQualifier(tree.selected) &&
-                tree.sym.kind == VAR) {
-                checkInit(tree.pos(), (VarSymbol)tree.sym);
+            if (TreeInfo.isThisQualifier(tree.selected) && tree.sym.kind == VAR) {
+                if (trackable((VarSymbol)tree.sym)) {
+                    checkInit(tree.pos(), (VarSymbol) tree.sym);
+                }
             }
         }
 

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

@@ -29,8 +29,10 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Symbol.ClassSymbol;
@@ -88,8 +90,8 @@ public static LocalProxyVarsGen instance(Context context) {
     private TreeMaker make;
     private final UnsetFieldsInfo unsetFieldsInfo;
     private ClassSymbol currentClass = null;
-    private java.util.List<JCVariableDecl> strictInstanceFields;
-    private Map<JCMethodDecl, Set<Symbol>> strictFieldsReadInPrologue = new HashMap<>();
+    private java.util.List<JCVariableDecl> instanceFields;
+    private Map<JCMethodDecl, Set<JCTree>> ASTsReferencedInPrologue = new HashMap<>();
 
     private final boolean noLocalProxyVars;
 
@@ -105,10 +107,27 @@ protected LocalProxyVarsGen(Context context) {
         noLocalProxyVars = options.isSet("noLocalProxyVars");
     }
 
-    public void addStrictFieldReadInPrologue(JCMethodDecl constructor, Symbol sym) {
-        Set<Symbol> fieldSet = strictFieldsReadInPrologue.getOrDefault(constructor, new HashSet<>());
-        fieldSet.add(sym);
-        strictFieldsReadInPrologue.put(constructor, fieldSet);
+    public void addASTReadInPrologue(JCMethodDecl constructor, JCTree tree) {
+        // better to have order for this one
+        Set<JCTree> treeSet = ASTsReferencedInPrologue.getOrDefault(constructor, new LinkedHashSet<>());
+        treeSet.add(tree);
+        ASTsReferencedInPrologue.put(constructor, treeSet);
+    }
+
+    public boolean removeASTReadInPrologue(JCMethodDecl constructor, JCTree tree) {
+        Set<JCTree> treeSet = ASTsReferencedInPrologue.get(constructor);
+        if (treeSet != null) {
+            return treeSet.remove(tree);
+        }
+        return false;
+    }
+
+    public boolean hasAST(JCMethodDecl constructor, JCTree tree) {
+        Set<JCTree> treeSet = ASTsReferencedInPrologue.get(constructor);
+        if (treeSet != null) {
+            return treeSet.contains(tree);
+        }
+        return false;
     }
 
     public JCTree translateTopLevelClass(JCTree cdef, TreeMaker make) {
@@ -128,32 +147,33 @@ public JCTree translateTopLevelClass(JCTree cdef, TreeMaker make) {
     @Override
     public void visitClassDef(JCClassDecl tree) {
         ClassSymbol prevCurrentClass = currentClass;
-        java.util.List<JCVariableDecl> prevStrictInstanceFields = strictInstanceFields;
+        java.util.List<JCVariableDecl> instanceFieldsPrev = instanceFields;
         try {
             currentClass = tree.sym;
-            strictInstanceFields = tree.defs.stream()
+            instanceFields = tree.defs.stream()
                     .filter(t -> t.hasTag(VARDEF))
                     .map(t -> (JCVariableDecl)t)
-                    .filter(vd -> vd.sym.isStrict() && !vd.sym.isStatic())
+                    .filter(vd -> !vd.sym.isStatic())
                     .collect(List.collector());
             super.visitClassDef(tree);
         } finally {
             currentClass = prevCurrentClass;
-            strictInstanceFields = prevStrictInstanceFields;
+            instanceFields = instanceFieldsPrev;
         }
     }
 
     public void visitMethodDef(JCMethodDecl tree) {
-        if (strictFieldsReadInPrologue.get(tree) != null) {
-            Set<Symbol> fieldSet = strictFieldsReadInPrologue.get(tree);
+        if (ASTsReferencedInPrologue.get(tree) != null) {
+            Set<JCTree> ASTSet = ASTsReferencedInPrologue.get(tree);
             java.util.List<JCVariableDecl> strictFieldsRead = new ArrayList<>();
-            for (JCVariableDecl sfield : strictInstanceFields) {
-                if (fieldSet.contains(sfield.sym)) {
+            Set<Symbol> symbols = ASTSet.stream().map(t -> TreeInfo.symbolFor(t)).collect(Collectors.toSet());
+            for (JCVariableDecl sfield : instanceFields) {
+                if (symbols.contains(sfield.sym)) {
                     strictFieldsRead.add(sfield);
                 }
             }
             addLocalProxiesFor(tree, strictFieldsRead);
-            strictFieldsReadInPrologue.remove(tree);
+            ASTsReferencedInPrologue.remove(tree);
         }
         super.visitMethodDef(tree);
     }