8333725: Compiler Prototyping for Deconstructors

make/langtools/src/classes/build/tools/symbolgenerator/CreateSymbols.java

@@ -941,16 +941,28 @@ private void addAttributes(MethodDescription desc, MethodBuilder builder) {
         if (desc.annotationDefaultValue != null) {
             builder.with(AnnotationDefaultAttribute.of(createAttributeValue(desc.annotationDefaultValue)));
         }
+        parameterableAttributes(desc).forEach(el -> builder.with((MethodElement) el));
+        if (desc.patternDescription != null) {
+            MethodTypeDesc methodType = MethodTypeDesc.ofDescriptor(desc.patternDescription.descriptor);
+            List<Attribute<?>> result = new ArrayList<>();
+            result.addAll(parameterableAttributes(desc.patternDescription).reversed());
+            builder.with(PatternAttribute.of(desc.patternDescription.name, desc.patternDescription.flags, methodType, result));
+        }
+    }
+
+    private List<Attribute<?>> parameterableAttributes(ParameterableDescription desc) {
+        List<Attribute<?>> result = new ArrayList<>();
         if (desc.classParameterAnnotations != null && !desc.classParameterAnnotations.isEmpty()) {
-            builder.with(RuntimeInvisibleParameterAnnotationsAttribute.of(createParameterAnnotations(desc.classParameterAnnotations)));
+            result.add(RuntimeInvisibleParameterAnnotationsAttribute.of(createParameterAnnotations(desc.classParameterAnnotations)));
         }
         if (desc.runtimeParameterAnnotations != null && !desc.runtimeParameterAnnotations.isEmpty()) {
-            builder.with(RuntimeVisibleParameterAnnotationsAttribute.of(createParameterAnnotations(desc.runtimeParameterAnnotations)));
+            result.add(RuntimeVisibleParameterAnnotationsAttribute.of(createParameterAnnotations(desc.runtimeParameterAnnotations)));
         }
         if (desc.methodParameters != null && !desc.methodParameters.isEmpty()) {
-            builder.with(MethodParametersAttribute.of(desc.methodParameters.stream()
+            result.add(MethodParametersAttribute.of(desc.methodParameters.stream()
                     .map(mp -> MethodParameterInfo.ofParameter(Optional.ofNullable(mp.name), mp.flags)).collect(Collectors.toList())));
         }
+        return result;
     }
 
     private void addAttributes(FieldDescription desc, FieldBuilder builder) {
@@ -2165,8 +2177,8 @@ private boolean readAttribute(FeatureDescription feature, Attribute<?> attr) {
             case EnclosingMethodAttribute _ -> {
                 return false;
             }
-            case RuntimeVisibleParameterAnnotationsAttribute a -> ((MethodDescription) feature).runtimeParameterAnnotations = parameterAnnotations2Description(a.parameterAnnotations());
-            case RuntimeInvisibleParameterAnnotationsAttribute a -> ((MethodDescription) feature).classParameterAnnotations = parameterAnnotations2Description(a.parameterAnnotations());
+            case RuntimeVisibleParameterAnnotationsAttribute a -> ((ParameterableDescription) feature).runtimeParameterAnnotations = parameterAnnotations2Description(a.parameterAnnotations());
+            case RuntimeInvisibleParameterAnnotationsAttribute a -> ((ParameterableDescription) feature).classParameterAnnotations = parameterAnnotations2Description(a.parameterAnnotations());
             case ModuleAttribute a -> {
                 ModuleHeaderDescription header = (ModuleHeaderDescription) feature;
                 header.name = a.moduleName().name().stringValue();
@@ -2204,15 +2216,28 @@ private boolean readAttribute(FeatureDescription feature, Attribute<?> attr) {
                     return rcd;
                 }).collect(Collectors.toList());
             }
-            case MethodParametersAttribute a -> ((MethodDescription) feature).methodParameters = a.parameters().stream()
-                    .map(mpi -> new MethodDescription.MethodParam(mpi.flagsMask(), mpi.name().map(Utf8Entry::stringValue).orElse(null)))
+            case MethodParametersAttribute a -> ((ParameterableDescription) feature).methodParameters = a.parameters().stream()
+                    .map(mpi -> new ParameterableDescription.MethodParam(mpi.flagsMask(), mpi.name().map(Utf8Entry::stringValue).orElse(null)))
                     .collect(Collectors.toList());
             case PermittedSubclassesAttribute a -> {
                 var chd = (ClassHeaderDescription) feature;
                 chd.isSealed = true;
                 chd.permittedSubclasses = a.permittedSubclasses().stream().map(ClassEntry::asInternalName).collect(Collectors.toList());
             }
             case ModuleMainClassAttribute a -> ((ModuleHeaderDescription) feature).moduleMainClass = a.mainClass().asInternalName();
+            case PatternAttribute a -> {
+                assert feature instanceof MethodDescription;
+                MethodDescription method = (MethodDescription) feature;
+                PatternDescription pd = new PatternDescription();
+                pd.flags = a.patternFlagsMask();
+                pd.name = a.patternName().stringValue();
+                pd.descriptor = a.patternMethodType().stringValue();
+                for (Attribute<?> patternAttr : a.attributes()) {
+                    readAttribute(pd, patternAttr);
+                }
+                method.patternDescription = pd;
+                break;
+            }
             case RuntimeVisibleTypeAnnotationsAttribute a -> {/* do nothing for now */}
             default -> throw new IllegalArgumentException("Unhandled attribute: " + attr.attributeName()); // Do nothing
         }
@@ -3264,15 +3289,13 @@ protected void readInnerClasses(LineBasedReader reader) throws IOException {
 
     }
 
-    static class MethodDescription extends FeatureDescription {
+    static class MethodDescription extends ParameterableDescription {
         static int METHODS_FLAGS_NORMALIZATION = ~0;
         String name;
         String descriptor;
         List<String> thrownTypes;
         Object annotationDefaultValue;
-        List<List<AnnotationDescription>> classParameterAnnotations;
-        List<List<AnnotationDescription>> runtimeParameterAnnotations;
-        List<MethodParam> methodParameters;
+        PatternDescription patternDescription;
 
         public MethodDescription() {
             flagsNormalization = METHODS_FLAGS_NORMALIZATION;
@@ -3309,6 +3332,9 @@ public boolean equals(Object obj) {
             if (!Objects.equals(this.annotationDefaultValue, other.annotationDefaultValue)) {
                 return false;
             }
+            if (!Objects.equals(this.patternDescription, other.patternDescription)) {
+                return false;
+            }
             return true;
         }
 
@@ -3331,6 +3357,144 @@ public void write(Appendable output, String baselineVersion, String version) thr
             if (annotationDefaultValue != null)
                 output.append(" annotationDefaultValue " + quote(AnnotationDescription.dumpAnnotationValue(annotationDefaultValue), false));
             writeAttributes(output);
+            output.append("\n");
+
+            if (patternDescription != null) {
+                patternDescription.write(output, baselineVersion, version);
+            }
+        }
+
+        @Override
+        public boolean read(LineBasedReader reader) throws IOException {
+            if (!"method".equals(reader.lineKey))
+                return false;
+
+            name = reader.attributes.get("name");
+            descriptor = reader.attributes.get("descriptor");
+
+            String thrownTypesValue = reader.attributes.get("thrownTypes");
+
+            if (thrownTypesValue != null) {
+                thrownTypes = deserializeList(thrownTypesValue);
+            }
+
+            String inAnnotationDefaultValue = reader.attributes.get("annotationDefaultValue");
+
+            if (inAnnotationDefaultValue != null) {
+                annotationDefaultValue = parseAnnotationValue(inAnnotationDefaultValue, new int[1]);
+            }
+
+            readAttributes(reader);
+
+            reader.moveNext();
+
+            if ("pattern-info".equals(reader.lineKey)) {
+                patternDescription = new PatternDescription();
+                patternDescription.read(reader);
+            }
+
+            return true;
+        }
+
+    }
+
+    static class PatternDescription extends ParameterableDescription {
+        String name;
+        String descriptor;
+
+        public PatternDescription() {
+        }
+
+        @Override
+        public int hashCode() {
+            int hash = super.hashCode();
+            hash = 59 * hash + Objects.hashCode(this.name);
+            hash = 59 * hash + Objects.hashCode(this.descriptor);
+            return hash;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            if (!super.equals(obj)) {
+                return false;
+            }
+            final MethodDescription other = (MethodDescription) obj;
+            if (!Objects.equals(this.name, other.name)) {
+                return false;
+            }
+            if (!Objects.equals(this.descriptor, other.descriptor)) {
+                return false;
+            }
+            return true;
+        }
+
+        @Override
+        public void write(Appendable output, String baselineVersion, String version) throws IOException {
+            output.append("pattern-info");
+            output.append(" name " + quote(name, false));
+            output.append(" descriptor " + quote(descriptor, false));
+            writeAttributes(output);
+            output.append("\n");
+        }
+
+        @Override
+        public boolean read(LineBasedReader reader) throws IOException {
+            if (!"pattern-info".equals(reader.lineKey))
+                return false;
+
+            name = reader.attributes.get("name");
+            descriptor = reader.attributes.get("descriptor");
+
+            readAttributes(reader);
+
+            reader.moveNext();
+
+            return true;
+        }
+
+    }
+
+    static abstract class ParameterableDescription extends FeatureDescription {
+        List<List<AnnotationDescription>> classParameterAnnotations;
+        List<List<AnnotationDescription>> runtimeParameterAnnotations;
+        List<MethodParam> methodParameters;
+
+        public ParameterableDescription() {
+        }
+
+        @Override
+        public int hashCode() {
+            int hash = super.hashCode();
+            return hash;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            if (!super.equals(obj)) {
+                return false;
+            }
+            final MethodDescription other = (MethodDescription) obj;
+            if (!Objects.equals(this.classParameterAnnotations, other.classParameterAnnotations)) {
+                return false;
+            }
+            if (!Objects.equals(this.runtimeParameterAnnotations, other.runtimeParameterAnnotations)) {
+                return false;
+            }
+            if (!Objects.equals(this.methodParameters, other.methodParameters)) {
+                return false;
+            }
+            return true;
+        }
+
+        @Override
+        public void writeAttributes(Appendable output) throws IOException {
+            super.writeAttributes(output);
             if (classParameterAnnotations != null && !classParameterAnnotations.isEmpty()) {
                 output.append(" classParameterAnnotations ");
                 for (List<AnnotationDescription> pa : classParameterAnnotations) {
@@ -3358,31 +3522,11 @@ public void write(Appendable output, String baselineVersion, String version) thr
                                          .collect(Collectors.toList());
                 output.append(" methodParameters " + serializeList(paramsAsStrings));
             }
-            output.append("\n");
         }
 
         @Override
-        public boolean read(LineBasedReader reader) throws IOException {
-            if (!"method".equals(reader.lineKey))
-                return false;
-
-            name = reader.attributes.get("name");
-            descriptor = reader.attributes.get("descriptor");
-
-            String thrownTypesValue = reader.attributes.get("thrownTypes");
-
-            if (thrownTypesValue != null) {
-                thrownTypes = deserializeList(thrownTypesValue);
-            }
-
-            String inAnnotationDefaultValue = reader.attributes.get("annotationDefaultValue");
-
-            if (inAnnotationDefaultValue != null) {
-                annotationDefaultValue = parseAnnotationValue(inAnnotationDefaultValue, new int[1]);
-            }
-
-            readAttributes(reader);
-
+        protected void readAttributes(LineBasedReader reader) {
+            super.readAttributes(reader);
             String inClassParamAnnotations = reader.attributes.get("classParameterAnnotations");
             if (inClassParamAnnotations != null) {
                 List<List<AnnotationDescription>> annos = new ArrayList<>();
@@ -3418,21 +3562,9 @@ public boolean read(LineBasedReader reader) throws IOException {
                                                           .map(string2Param)
                                                           .collect(Collectors.toList());
             }
-
-            reader.moveNext();
-
-            return true;
         }
 
-        public static class MethodParam {
-            public final int flags;
-            public final String name;
-
-            public MethodParam(int flags, String name) {
-                this.flags = flags;
-                this.name = name;
-            }
-        }
+        public record MethodParam(int flags, String name) {}
     }
 
     static class FieldDescription extends FeatureDescription {

make/modules/jdk.compiler/Gendata.gmk

@@ -57,23 +57,27 @@ COMPILECREATESYMBOLS_ADD_EXPORTS := \
 
 # TODO: Unify with jdk.javadoc-gendata. Should only compile this once and share.
 $(eval $(call SetupJavaCompilation, COMPILE_CREATE_SYMBOLS, \
-    TARGET_RELEASE := $(TARGET_RELEASE_NEWJDK), \
-    COMPILER := buildjdk, \
     SRC := $(TOPDIR)/make/langtools/src/classes, \
     INCLUDES := build/tools/symbolgenerator, \
     BIN := $(BUILDTOOLS_OUTPUTDIR)/create_symbols_javac, \
     DISABLED_WARNINGS := options, \
     JAVAC_FLAGS := \
+        --module-path $(JDK_OUTPUTDIR)/modules \
+        --system none \
+        --add-modules jdk.compiler \
         $(COMPILECREATESYMBOLS_ADD_EXPORTS), \
 ))
 
-$(SUPPORT_OUTPUTDIR)/symbols/ct.sym: $(COMPILE_CREATE_SYMBOLS) $(SYMBOL_FILES) \
+#    TARGET_RELEASE := $(TARGET_RELEASE_NEWJDK), \
+#    COMPILER := buildjdk, \
+
+$(SUPPORT_OUTPUTDIR)/symbols/ct.sym: $(COMPILE_CREATE_SYMBOLS) $(SYMBOL_FILES) $(JDK_OUTPUTDIR)/bin/java$(EXECUTABLE_SUFFIX) \
     $(MODULE_INFOS) $(CT_MODULES_API_TARGETS)
 	$(RM) -r $(@D)
 	$(MKDIR) -p $(@D)
 	$(ECHO) Creating ct.sym classes
 	$(ECHO) $(CT_MODULES) $(CT_TRANSITIVE_MODULES) $(CT_EXTRA_MODULES) >$(SUPPORT_OUTPUTDIR)/symbols/included-modules
-	$(BUILD_JAVA_SMALL) \
+	$(FIXPATH) $(JDK_OUTPUTDIR)/bin/java$(EXECUTABLE_SUFFIX) \
 	    $(COMPILECREATESYMBOLS_ADD_EXPORTS) \
 	    -classpath $(BUILDTOOLS_OUTPUTDIR)/create_symbols_javac \
 	    build.tools.symbolgenerator.CreateSymbols \

make/modules/jdk.javadoc/Gendata.gmk

@@ -39,23 +39,21 @@ JAVADOC_MODULESOURCEPATH := $(call GetModuleSrcPath)
 CT_DATA_DESCRIPTION += $(TOPDIR)/src/jdk.compiler/share/data/symbols/symbols
 
 COMPILECREATESYMBOLS_ADD_EXPORTS := \
-    --add-exports java.base/jdk.internal=java.compiler.interim,jdk.compiler.interim \
-    --add-exports jdk.internal.opt/jdk.internal.opt=jdk.compiler.interim,jdk.javadoc.interim \
-    --add-exports jdk.compiler.interim/com.sun.tools.javac.api=ALL-UNNAMED \
-    --add-exports jdk.compiler.interim/com.sun.tools.javac.code=ALL-UNNAMED \
-    --add-exports jdk.compiler.interim/com.sun.tools.javac.util=ALL-UNNAMED \
-    --add-exports jdk.compiler.interim/com.sun.tools.javac.jvm=ALL-UNNAMED \
+    --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED \
+    --add-exports jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED \
+    --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED \
+    --add-exports jdk.compiler/com.sun.tools.javac.jvm=ALL-UNNAMED \
     #
 
 $(eval $(call SetupJavaCompilation, COMPILE_CREATE_SYMBOLS, \
-    TARGET_RELEASE := $(TARGET_RELEASE_BOOTJDK), \
-    SRC := $(TOPDIR)/make/langtools/src/classes \
-        $(TOPDIR)/src/jdk.jdeps/share/classes, \
+    SRC := $(TOPDIR)/make/langtools/src/classes, \
     INCLUDES := build/tools/symbolgenerator, \
     BIN := $(BUILDTOOLS_OUTPUTDIR)/create_symbols_javadoc, \
     DISABLED_WARNINGS := options, \
     JAVAC_FLAGS := \
-        $(INTERIM_LANGTOOLS_ARGS) \
+        --module-path $(JDK_OUTPUTDIR)/modules \
+        --system none \
+        --add-modules jdk.compiler \
         $(COMPILECREATESYMBOLS_ADD_EXPORTS), \
 ))
 
@@ -67,15 +65,15 @@ ELEMENT_LISTS_DIR := $(JDK_JAVADOC_DIR)/$(ELEMENT_LISTS_PKG)
 $(JDK_JAVADOC_DIR)/_element_lists.marker: \
     $(COMPILE_CREATE_SYMBOLS) \
     $(wildcard $(TOPDIR)/src/jdk.compiler/share/data/symbols/*) \
-    $(MODULE_INFOS)
+    $(MODULE_INFOS) $(JDK_OUTPUTDIR)/bin/java$(EXECUTABLE_SUFFIX)
 	$(call MakeTargetDir)
 	$(call LogInfo, Creating javadoc element lists)
 	$(RM) $(ELEMENT_LISTS_DIR)/element-list-{$(call CommaList, \
 		$(call sequence, $(GENERATE_SYMBOLS_FROM_JDK_VERSION), \
 				 $(JDK_SOURCE_TARGET_VERSION)))}.txt
         # Generate element-list files for JDK 11 to current-1
 	$(call ExecuteWithLog, $@_historic, \
-	    $(JAVA_SMALL) $(INTERIM_LANGTOOLS_ARGS) \
+	    $(FIXPATH) $(JDK_OUTPUTDIR)/bin/java$(EXECUTABLE_SUFFIX) \
 	        $(COMPILECREATESYMBOLS_ADD_EXPORTS) \
 	        -classpath $(BUILDTOOLS_OUTPUTDIR)/create_symbols_javadoc \
 	        build.tools.symbolgenerator.CreateSymbols \
@@ -86,7 +84,7 @@ $(JDK_JAVADOC_DIR)/_element_lists.marker: \
 	)
         # Generate element-list file for the current JDK version
 	$(call ExecuteWithLog, $@_current, \
-	    $(JAVA_SMALL) $(INTERIM_LANGTOOLS_ARGS) \
+	    $(FIXPATH) $(JDK_OUTPUTDIR)/bin/java$(EXECUTABLE_SUFFIX) \
 	        $(COMPILECREATESYMBOLS_ADD_EXPORTS) \
 	        -classpath $(BUILDTOOLS_OUTPUTDIR)/create_symbols_javadoc \
 	        build.tools.symbolgenerator.JavadocElementList \