8310678: [lw5] add implicit constructors

src/java.base/share/classes/java/lang/NonAtomic.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * A restricted interface optionally implemented by value objects.
+ *
+ * A value object is an instance of a value class, lacking identity.
+ *
+ * Every object is either an *identity object* or a *value object*. Identity
+ * objects have a unique identity determined for them at instance creation time and
+ * preserved throughout their life.
+ *
+ * value objects do *not* have an identity. Instead, they simply aggregate a
+ * set of immutable field values. The lack of identity enables certain performance
+ * optimizations by Java Virtual Machine implementations.
+ * The following operations have special behavior when applied to value
+ * objects:
+ *
+ * - The `==` operator, and the default implementation of the `Object.equals`
+ * method, compare the values of the operands' fields. Value objects
+ * created at different points in a program may be `==`.
+ *
+ * - The `System.identityHashCode` method, and the default implementation of the
+ * `Object.hashCode` method, generate a hash code from the hash codes of a
+ * value object's fields.
+ *
+ * - The `synchronized` modifier and `synchronized` statement always fail when
+ * applied to a value object.
+ *
+ * A value class with an `implicit` constructor may also declare that it tolerates
+ * implicit creation of instances via non-atomic field and array updates.
+ * This means that, in a race condition, new class instances may be accidentally
+ * created by intermixing field values from other instances, without any code
+ * execution or other additional cooperation from the value class. A value class
+ * opts in to allowing this behavior by implementing this interface.
+ *
+ * @since Valhalla
+ */
+
+public interface NonAtomic {
+}

src/java.compiler/share/classes/javax/lang/model/element/Modifier.java

@@ -97,6 +97,12 @@ public String toString() {
      */
     IDENTITY,
 
+    /**
+     * The modifier {@code implicit}
+     * @since 21
+     */
+    IMPLICIT,
+
     /** The modifier {@code final} */           FINAL,
     /** The modifier {@code transient} */       TRANSIENT,
     /** The modifier {@code volatile} */        VOLATILE,

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java

@@ -105,11 +105,13 @@ public static EnumSet<Flag> asFlagSet(long flags) {
     // bit positions, we translate them when reading and writing class
     // files into unique bits positions: ACC_SYNTHETIC <-> SYNTHETIC,
     // for example.
-    public static final int ACC_IDENTITY = 0x0020;
-    public static final int ACC_VALUE    = 0x0040;
-    public static final int ACC_BRIDGE   = 0x0040;
-    public static final int ACC_VARARGS  = 0x0080;
-    public static final int ACC_MODULE   = 0x8000;
+    public static final int ACC_DEFAULT    = 0x0001;
+    public static final int ACC_NON_ATOMIC = 0x0002;
+    public static final int ACC_IDENTITY   = 0x0020;
+    public static final int ACC_VALUE      = 0x0040;
+    public static final int ACC_BRIDGE     = 0x0040;
+    public static final int ACC_VARARGS    = 0x0080;
+    public static final int ACC_MODULE     = 0x8000;
 
     /*****************************************
      * Internal compiler flags (no bits in the lower 16).
@@ -419,6 +421,11 @@ public static EnumSet<Flag> asFlagSet(long flags) {
      */
     public static final long NON_SEALED = 1L<<63; // ClassSymbols
 
+    /**
+     * Flag to indicate that a value class constructor is implicit
+     */
+    public static final int IMPLICIT    = 1<<59; // MethodSymbols
+
     /**
      * Describe modifier flags as they migh appear in source code, i.e.,
      * separated by spaces and in the order suggested by JLS 8.1.1.
@@ -441,7 +448,7 @@ public static String toSource(long flags) {
         InterfaceVarFlags                 = FINAL | STATIC | PUBLIC,
         VarFlags                          = AccessFlags | FINAL | STATIC |
                                             VOLATILE | TRANSIENT | ENUM,
-        ConstructorFlags                  = AccessFlags,
+        ConstructorFlags                  = AccessFlags | IMPLICIT,
         InterfaceMethodFlags              = ABSTRACT | PUBLIC,
         MethodFlags                       = AccessFlags | ABSTRACT | STATIC | NATIVE |
                                             SYNCHRONIZED | FINAL | STRICTFP,
@@ -455,7 +462,7 @@ public static String toSource(long flags) {
         ExtendedClassFlags                = (long)ClassFlags | SEALED | NON_SEALED | VALUE_CLASS,
         ExtendedLocalClassFlags           = (long) LocalClassFlags | VALUE_CLASS,
         ExtendedStaticLocalClassFlags     = (long) StaticLocalClassFlags | VALUE_CLASS,
-        ModifierFlags                     = ((long)StandardFlags & ~INTERFACE) | DEFAULT | SEALED | NON_SEALED | VALUE_CLASS,
+        ModifierFlags                     = ((long)StandardFlags & ~INTERFACE) | DEFAULT | SEALED | NON_SEALED | VALUE_CLASS | IMPLICIT,
         InterfaceMethodMask               = ABSTRACT | PRIVATE | STATIC | PUBLIC | STRICTFP | DEFAULT,
         AnnotationTypeElementMask         = ABSTRACT | PUBLIC,
         LocalVarFlags                     = FINAL | PARAMETER,
@@ -482,6 +489,7 @@ public static Set<Modifier> asModifierSet(long flags) {
             if (0 != (flags & STRICTFP))  modifiers.add(Modifier.STRICTFP);
             if (0 != (flags & DEFAULT))   modifiers.add(Modifier.DEFAULT);
             if (0 != (flags & VALUE_CLASS))     modifiers.add(Modifier.VALUE);
+            if (0 != (flags & IMPLICIT))        modifiers.add(Modifier.IMPLICIT);
             modifiers = Collections.unmodifiableSet(modifiers);
             modifierSets.put(flags, modifiers);
         }
@@ -503,7 +511,6 @@ public static boolean isConstant(Symbol.VarSymbol symbol) {
         return symbol.getConstValue() != null;
     }
 
-
     public enum Flag {
         PUBLIC(Flags.PUBLIC),
         PRIVATE(Flags.PRIVATE),
@@ -531,6 +538,7 @@ public String toString() {
                 return "identity";
             }
         },
+        IMPLICIT(Flags.IMPLICIT),
         UNNAMED_CLASS(Flags.UNNAMED_CLASS),
         BLOCK(Flags.BLOCK),
         FROM_SOURCE(Flags.FROM_SOURCE),

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Source.java

@@ -238,7 +238,6 @@ public enum Feature {
         UNCONDITIONAL_PATTERN_IN_INSTANCEOF(JDK21, Fragments.FeatureUnconditionalPatternsInInstanceof, DiagKind.PLURAL),
         RECORD_PATTERNS(JDK21, Fragments.FeatureDeconstructionPatterns, DiagKind.PLURAL),
         STRING_TEMPLATES(JDK21, Fragments.FeatureStringTemplates, DiagKind.PLURAL),
-        PRIMITIVE_CLASSES(JDK21, Fragments.FeaturePrimitiveClasses, DiagKind.PLURAL),
         VALUE_CLASSES(JDK21, Fragments.FeatureValueClasses, DiagKind.PLURAL),
         UNNAMED_CLASSES(JDK21, Fragments.FeatureUnnamedClasses, DiagKind.PLURAL),
         WARN_ON_ILLEGAL_UTF8(MIN, JDK21),

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symbol.java

@@ -485,6 +485,12 @@ public boolean isValueObjectFactory() {
         return name == name.table.names.vnew && this.type.getReturnType().tsym == this.owner;
     }
 
+    /** Is this symbol an implicit constructor?
+     */
+    public boolean isImplicitConstructor() {
+        return isInitOrVNew() && ((flags() & IMPLICIT) != 0);
+    }
+
     /** Is this symbol a constructor or value factory?
      */
     public boolean isInitOrVNew() {
@@ -1679,6 +1685,21 @@ public List<Type> getPermittedSubclasses() {
         public boolean isUnnamed() {
             return (flags_field & Flags.UNNAMED_CLASS) != 0 ;
         }
+
+        public MethodSymbol getImplicitConstructor() {
+            for (Symbol s : members().getSymbols(NON_RECURSIVE)) {
+                switch (s.kind) {
+                    case MTH:
+                        if (s.isInitOrVNew()) {
+                            if (s.isImplicitConstructor()) {
+                                return (MethodSymbol) s;
+                            }
+                        }
+                }
+            }
+            return null;
+        }
+
     }
 
 

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symtab.java

@@ -245,6 +245,9 @@ public static Symtab instance(Context context) {
     public final Type processorType;
     public final Type linkageType;
 
+    // for value objects
+    public final Type nonAtomicType;
+
     /** The symbol representing the length field of an array.
      */
     public final VarSymbol lengthVar;
@@ -640,6 +643,9 @@ public <R, P> R accept(ElementVisitor<R, P> v, P p) {
         processorType = enterClass("java.lang.StringTemplate$Processor");
         linkageType = enterClass("java.lang.StringTemplate$Processor$Linkage");
 
+        // for value objects
+        nonAtomicType = enterClass("java.lang.NonAtomic");
+
         // Enter a synthetic class that is used to mark internal
         // proprietary classes in ct.sym.  This class does not have a
         // class file.

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

@@ -1162,6 +1162,14 @@ public void visitMethodDef(JCMethodDecl tree) {
             for (List<JCExpression> l = tree.thrown; l.nonEmpty(); l = l.tail)
                 chk.checkType(l.head.pos(), l.head.type, syms.throwableType);
 
+            if (tree.sym.isImplicitConstructor()) {
+                if (tree.body == null) {
+                    tree.body = make.Block(0, List.nil());
+                } else {
+                    log.error(tree.pos(), Errors.ImplicitConstCantHaveBody);
+                }
+            }
+
             if (tree.body == null) {
                 // Empty bodies are only allowed for
                 // abstract, native, or interface methods, or for methods
@@ -5371,6 +5379,11 @@ public void attribClass(DiagnosticPosition pos, ClassSymbol c) {
         try {
             annotate.flush();
             attribClass(c);
+            if (c.type.isValueClass()) {
+                final Env<AttrContext> env = typeEnvs.get(c);
+                if (env != null && env.tree != null && env.tree.hasTag(CLASSDEF) && TreeInfo.getImplicitConstructor(((JCClassDecl)env.tree).defs) != null)
+                    chk.checkNonCyclicMembership((JCClassDecl)env.tree);
+            }
         } catch (CompletionFailure ex) {
             chk.completionError(pos, ex);
         }
@@ -5548,7 +5561,7 @@ void attribClass(ClassSymbol c) throws CompletionFailure {
 
                 if (c.isValueClass()) {
                     Assert.check(env.tree.hasTag(CLASSDEF));
-                    chk.checkConstraintsOfValueClass(env.tree.pos(), c);
+                    chk.checkConstraintsOfValueClass((JCClassDecl) env.tree, c);
                 }
 
                 attribClassBody(env, c);

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

@@ -758,7 +758,9 @@ private Object asTypeParam(Type t) {
                                     : t;
         }
 
-    void checkConstraintsOfValueClass(DiagnosticPosition pos, ClassSymbol c) {
+    void checkConstraintsOfValueClass(JCClassDecl tree, ClassSymbol c) {
+        DiagnosticPosition pos = tree.pos();
+        checkConstraintsOfValueClassesWithImplicitConst(tree, c);
         for (Type st : types.closure(c.type)) {
             if (st == null || st.tsym == null || st.tsym.kind == ERR)
                 continue;
@@ -809,6 +811,28 @@ void checkConstraintsOfValueClass(DiagnosticPosition pos, ClassSymbol c) {
         }
     }
 
+    void checkConstraintsOfValueClassesWithImplicitConst(JCClassDecl classDecl, ClassSymbol c) {
+        JCMethodDecl implicitConstructor = TreeInfo.getImplicitConstructor(classDecl.defs);
+        if (implicitConstructor != null) {
+            Type encl = c.type.getEnclosingType();
+            if (encl != null && encl.hasTag(CLASS)) {
+                log.error(classDecl.pos(), Errors.ValueClassWithImplicitCannotBeInner(c));
+            }
+            if ((c.flags() & HASINITBLOCK) != 0) {
+                log.error(classDecl.pos(), Errors.ValueClassWithImplicitDeclaresInitBlock(c));
+            }
+            for (Symbol s : c.members().getSymbols(NON_RECURSIVE)) {
+                switch (s.kind) {
+                    case VAR:
+                        if ((s.flags() & STATIC) == 0 & (s.flags() & HASINIT) != 0) {
+                            log.error(classDecl.pos(), Errors.ValueClassWithImplicitInstanceFieldInitializer(c));
+                        }
+                        break;
+                }
+            }
+        }
+    }
+
     /** Check that type is a valid qualifier for a constructor reference expression
      */
     Type checkConstructorRefType(JCExpression expr, Type t) {
@@ -1442,7 +1466,13 @@ && checkDisjoint(pos, flags,
                                 ANNOTATION)
                 && checkDisjoint(pos, flags,
                                 VALUE_CLASS,
-                                ANNOTATION) ) {
+                                ANNOTATION)
+                && checkDisjoint(pos, flags,
+                                IMPLICIT,
+                                PRIVATE)
+                && checkDisjoint(pos, flags,
+                                IMPLICIT,
+                                PROTECTED) ) {
             // skip
         }
         return flags & (mask | ~ExtendedStandardFlags) | implicit;
@@ -2440,6 +2470,7 @@ void checkAllDefined(DiagnosticPosition pos, ClassSymbol c) {
     }
 
     // A primitive class cannot contain a field of its own type either or indirectly.
+    // TODO, update this method once we have null restricted types
     void checkNonCyclicMembership(JCClassDecl tree) {
         Assert.check((tree.sym.flags_field & LOCKED) == 0);
         try {
@@ -2473,7 +2504,7 @@ private void checkNonCyclicMembership(ClassSymbol c, DiagnosticPosition pos) {
     }
         // where
         private boolean cyclePossible(VarSymbol symbol) {
-            return (symbol.flags() & STATIC) == 0;
+            return (symbol.flags() & STATIC) == 0 && symbol.type.isValueClass();
         }
 
     void checkNonCyclicDecl(JCClassDecl tree) {

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

@@ -2553,7 +2553,7 @@ public void visitMethodDef(JCMethodDecl tree) {
                                     } else {
                                         checkInit(TreeInfo.diagnosticPositionFor(var, vardecl), var);
                                     }
-                                } else {
+                                } else if (!tree.sym.isImplicitConstructor()) { // implicit constructors are special, ignore them
                                     checkInit(TreeInfo.diagEndPos(tree.body), var);
                                 }
                             }

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

@@ -244,7 +244,8 @@ public void visitMethodDef(JCMethodDecl tree) {
         }
 
         if (m.isInitOrVNew() && m.type.getParameterTypes().size() == 0) {
-            int statsSize = tree.body.stats.size();
+            // implicit constructors are empty bodied
+            int statsSize = (tree.body == null) && ((tree.mods.flags & IMPLICIT) != 0) ? 0 : tree.body.stats.size();
             if (statsSize == 0) {
                 m.flags_field |= EMPTYNOARGCONSTR;
             } else if (statsSize == 1 && TreeInfo.isSuperCall(tree.body.stats.head)) {

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

@@ -1070,6 +1070,7 @@ protected void runPhase(Env<AttrContext> env) {
                 defaultConstructor = defaultConstructor(make.at(tree.pos), helper);
                 tree.defs = tree.defs.prepend(defaultConstructor);
             }
+
             if (!sym.isRecord()) {
                 enterThisAndSuper(sym, env);
             }

src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassReader.java

@@ -132,6 +132,10 @@ public class ClassReader {
      */
     public boolean saveParameterNames;
 
+    /** Switch: does this value class has an implicit constructor
+     */
+    public boolean hasImplicitConstructor;
+
     /**
      * The currently selected profile.
      */
@@ -1332,6 +1336,27 @@ protected void read(Symbol sym, int attrLen) {
                     }
                 }
             },
+            new AttributeReader(names.ImplicitCreation, V63, CLASS_ATTRIBUTE) {
+                @Override
+                protected boolean accepts(AttributeKind kind) {
+                    return super.accepts(kind) && allowValueClasses;
+                }
+                protected void read(Symbol sym, int attrLen) {
+                    if (sym.kind == TYP) {
+                        nextChar();
+                        hasImplicitConstructor = true;
+                    }
+                }
+            },
+            new AttributeReader(names.NullRestricted, V63, MEMBER_ATTRIBUTE) {
+                @Override
+                protected boolean accepts(AttributeKind kind) {
+                    return super.accepts(kind) && allowValueClasses;
+                }
+                protected void read(Symbol sym, int attrLen) {
+                    // here we could put the nullness annotation into the field's type
+                }
+            },
         };
 
         for (AttributeReader r: readers)
@@ -2341,6 +2366,10 @@ MethodSymbol readMethod() {
                     syms.voidType,
                     type.getThrownTypes(),
                     syms.methodClass);
+            if (hasImplicitConstructor && type.getParameterTypes().size() == 0) {
+                // this has to be the implicit constructor
+                flags |= IMPLICIT;
+            }
         }
         validateMethodType(name, type);
         if (names.isInitOrVNew(name) && currentOwner.hasOuterInstance()) {