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);
 
@@ -1252,6 +1254,25 @@ public void visitMethodDef(JCMethodDecl tree) {
 
                 // Attribute method body.
                 attribStat(tree.body, localEnv);
+                if (isConstructor) {
+                    ListBuffer<JCTree> prologueCode = new ListBuffer<>();
+                    for (JCTree stat : tree.body.stats) {
+                        prologueCode.add(stat);
+                        /* gather all the stats in the body until a `super` or `this` constructor invocation is found,
+                         * including the constructor invocation, that way we don't need to worry in the visitor below if
+                         * if we are dealing or not with prologue code
+                         */
+                        if (stat instanceof JCExpressionStatement expStmt &&
+                                expStmt.expr instanceof JCMethodInvocation mi &&
+                                TreeInfo.isConstructorCall(mi)) {
+                            break;
+                        }
+                    }
+                    if (!prologueCode.isEmpty()) {
+                        CtorPrologueVisitor ctorPrologueVisitor = new CtorPrologueVisitor(localEnv);
+                        ctorPrologueVisitor.scan(prologueCode.toList());
+                    }
+                }
             }
 
             localEnv.info.scope.leave();
@@ -1263,6 +1284,209 @@ public void visitMethodDef(JCMethodDecl tree) {
         }
     }
 
+    class CtorPrologueVisitor extends TreeScanner {
+        Env<AttrContext> localEnv;
+        CtorPrologueVisitor(Env<AttrContext> localEnv) {
+            this.localEnv = localEnv;
+        }
+
+        @Override
+        public void visitLambda(JCLambda lambda) {
+            super.visitLambda(lambda);
+            classDeclAndLambdaHelper(TreeInfo.symbolsFor(lambda.body));
+        }
+
+        @Override
+        public void visitClassDef(JCClassDecl classDecl) {
+            super.visitClassDef(classDecl);
+            classDeclAndLambdaHelper(TreeInfo.symbolsFor(classDecl.defs));
+        }
+
+        private void classDeclAndLambdaHelper(java.util.List<TreeInfo.SymAndTree> symbols) {
+            for (TreeInfo.SymAndTree symAndTree : symbols) {
+                Symbol sym = symAndTree.symbol();
+                JCTree tree = TreeInfo.skipParens(symAndTree.tree());
+                if (sym.kind == VAR &&
+                        rs.isEarlyReference(
+                                true, // localEnv could potentially have the `ctorPrologue` field set to false
+                                localEnv,
+                                tree instanceof JCFieldAccess fa ?
+                                        fa.selected :
+                                        null,
+                                sym)) {
+                    reportPrologueError(tree, sym);
+                }
+            }
+        }
+
+        private void reportPrologueError(JCTree tree, Symbol sym) {
+            preview.checkSourceLevel(tree, Feature.FLEXIBLE_CONSTRUCTORS);
+            log.error(tree, Errors.CantRefBeforeCtorCalled(sym));
+        }
+
+        @Override
+        public void visitApply(JCMethodInvocation tree) {
+            super.visitApply(tree);
+            Name name = TreeInfo.name(tree.meth);
+            boolean isConstructorCall = name == names._this || name == names._super;
+            Symbol msym = TreeInfo.symbolFor(tree.meth);
+            // is this an instance method call or an illegal constructor invocation like: `this.super()`?
+            if (msym != null && // for erroneous invocations msym can be null, ignore those
+                (!isConstructorCall ||
+                isConstructorCall && tree.meth.hasTag(SELECT))) {
+                if (rs.isEarlyReference(
+                        true,
+                        localEnv,
+                        tree.meth instanceof JCFieldAccess fa ? fa.selected : null,
+                        msym))
+                    reportPrologueError(tree.meth, msym);
+            }
+        }
+
+        @Override
+        public void visitIdent(JCIdent tree) {
+            // skip if this identifier is part of a select, context is important here
+            if (!analyzingSelect) {
+                analyzeSymbol(tree);
+            }
+        }
+
+        boolean analyzingSelect = false;
+
+        @Override
+        public void visitSelect(JCFieldAccess tree) {
+            // skip if part of a larger select, context is important here
+            if (!analyzingSelect) {
+                boolean previousAnalyzingSelect = analyzingSelect;
+                try {
+                    analyzingSelect = true;
+                    super.visitSelect(tree);
+                    analyzeSymbol(tree);
+                } finally {
+                    analyzingSelect = previousAnalyzingSelect;
+                }
+            }
+        }
+
+        @Override
+        public void visitNewClass(JCNewClass tree) {
+            super.visitNewClass(tree);
+            checkNewClassAndMethRefs(tree, tree.type);
+        }
+
+        @Override
+        public void visitReference(JCMemberReference tree) {
+            super.visitReference(tree);
+            if (tree.getMode() == JCMemberReference.ReferenceMode.NEW) {
+                checkNewClassAndMethRefs(tree, tree.expr.type);
+            }
+        }
+
+        void checkNewClassAndMethRefs(JCTree tree, Type t) {
+            if (t.tsym.isEnclosedBy(localEnv.enclClass.sym) &&
+                    !t.tsym.isStatic() &&
+                    !t.tsym.isDirectlyOrIndirectlyLocal()) {
+                reportPrologueError(tree, t.getEnclosingType().tsym);
+            }
+        }
+
+        /* if a symbol is in the LHS of an assignment expression we won't consider it as a candidate
+         * for a proxy local variable later on
+         */
+        boolean isInLHS = false;
+
+        @Override
+        public void visitAssign(JCAssign tree) {
+            boolean previousIsInLHS = isInLHS;
+            try {
+                isInLHS = true;
+                scan(tree.lhs);
+            } finally {
+                isInLHS = previousIsInLHS;
+            }
+            scan(tree.rhs);
+        }
+
+        @Override
+        public void visitMethodDef(JCMethodDecl tree) {
+            // ignore any declarative part, mainly to avoid scanning receiver parameters
+            scan(tree.body);
+        }
+
+        void analyzeSymbol(JCTree tree) {
+            tree = TreeInfo.skipParens(tree);
+            Symbol sym = TreeInfo.symbolFor(tree);
+            if (sym != null) {
+                if (!sym.isStatic() && !isMethodArgument(tree)) {
+                    if (sym.name == names._this || sym.name == names._super) {
+                        // are we seeing something like `this` or `CurrentClass.this` or `SuperClass.super::foo`?
+                        if (TreeInfo.isExplicitThisReference(
+                                types,
+                                (ClassType)localEnv.enclClass.sym.type,
+                                tree)) {
+                            reportPrologueError(tree, sym);
+                        }
+                    } else if (sym.kind == VAR && sym.owner.kind == TYP) { // now fields only
+                        if (sym.owner != localEnv.enclClass.sym) {
+                            if (localEnv.enclClass.sym.isSubClass(sym.owner, types) &&
+                                    sym.isInheritedIn(localEnv.enclClass.sym, types)) {
+                                /* if we are dealing with a field that doesn't belong to the current class, but the
+                                 * field is inherited, this is an error. Unless, the super class is also an outer
+                                 * class and the field's qualifier refers to the outer class
+                                 */
+                                if (tree.hasTag(IDENT) ||
+                                    TreeInfo.isExplicitThisReference(
+                                            types,
+                                            (ClassType)localEnv.enclClass.sym.type,
+                                            ((JCFieldAccess)tree).selected)) {
+                                    reportPrologueError(tree, sym);
+                                }
+                            }
+                        } else if (rs.isEarlyReference( // now this is a `proper` instance field of the current class
+                                        true,
+                                        localEnv,
+                                        tree.hasTag(SELECT) ? ((JCFieldAccess)tree).selected : null,
+                                        sym
+                                )) {
+                            /* references to fields of identity classes which happen to have initializers are
+                             * not allowed in the prologue
+                             */
+                            if (!localEnv.enclClass.sym.isValueClass() && (sym.flags_field & HASINIT) != 0)
+                                reportPrologueError(tree, sym);
+                            // we will need to generate a proxy for this field later on
+                            if (!isInLHS)
+                                localProxyVarsGen.addFieldReadInPrologue(localEnv.enclMethod, sym);
+                        }
+                    }
+                }
+            }
+        }
+
+        boolean isMethodArgument(JCTree tree) {
+            JCTree treeToCheck = null;
+            if (tree.hasTag(IDENT)) {
+                treeToCheck = tree;
+            } else if (tree instanceof JCFieldAccess) {
+                JCFieldAccess fa = (JCFieldAccess) tree;
+                while (fa.selected.hasTag(SELECT)) {
+                    fa = (JCFieldAccess)fa.selected;
+                }
+                treeToCheck = fa;
+            }
+            if (treeToCheck != null) {
+                Symbol sym = TreeInfo.symbolFor(
+                        treeToCheck instanceof JCFieldAccess fa ?
+                                fa.selected :
+                                treeToCheck
+                );
+                if (sym != null){
+                    return sym.owner.kind == MTH;
+                }
+            }
+            return false;
+        }
+    }
+
     public void visitVarDef(JCVariableDecl tree) {
         // Local variables have not been entered yet, so we need to do it now:
         if (env.info.scope.owner.kind == MTH || env.info.scope.owner.kind == VAR) {
@@ -1335,6 +1559,11 @@ public void visitVarDef(JCVariableDecl tree) {
                             //fixup local variable type
                             v.type = chk.checkLocalVarType(tree, tree.init.type, tree.name);
                         }
+                        if (v.owner.kind == TYP && !v.isStatic() && v.isStrict()) {
+                            // strict field initializers are inlined in constructor's prologues
+                            CtorPrologueVisitor ctorPrologueVisitor = new CtorPrologueVisitor(initEnv);
+                            ctorPrologueVisitor.scan(tree.init);
+                        }
                     } finally {
                         initEnv.info.ctorPrologue = previousCtorPrologue;
                     }