Eclipse 4.22 (M1) JDT Patch for Groovy-Eclipse

https://git.eclipse.org/c/jdt/eclipse.jdt.core.git/tag/?h=S4_22_0_M1

#1302 #1303

Author: eric-milles

base-test/org.eclipse.jdt.groovy.core.tests.compiler/src/org/eclipse/jdt/groovy/core/tests/basic/EnumerationTests.java

@@ -658,7 +658,7 @@ public void testEnum13() {
             "}\n" +
             "\n" +
             "class A {\n" +
-            "  public enum C2{\n" +
+            "  enum C2{\n" +
             "    TEST_C2\n" +
             "  }\n" +
             "}\n",
@@ -699,6 +699,26 @@ public void testEnum13() {
         //@formatter:on
 
         runConformTest(sources);
+
+        checkGCUDeclaration("A.groovy",
+            "package be.flow;\n" +
+            "public enum C1 {\n" +
+            "  TEST_C1,\n" +
+            "  private @groovy.transform.Generated C1() {\n" +
+            "  }\n" +
+            "}\n" +
+            "public class A {\n" +
+            "  public static enum C2 {\n" +
+            "    TEST_C2,\n" +
+            "    private @groovy.transform.Generated C2() {\n" +
+            "    }\n" +
+            "  }\n" +
+            "  public @groovy.transform.Generated A() {\n" +
+            "  }\n" +
+            "}");
+
+        checkDisassemblyFor("be/flow/A$C2.class",
+            "public static final enum be.flow.A$C2 implements ");
     }
 
     @Test
@@ -914,6 +934,9 @@ public void testAbstractMethodWithinEnum1() {
             "  }\n" +
             "  public abstract int foo();\n" +
             "}");
+
+        checkDisassemblyFor("Good.class", "public abstract enum Good ");
+        checkDisassemblyFor("Good$1.class", "\nfinal enum Good$1 {\n ");
     }
 
     @Test

base-test/org.eclipse.jdt.groovy.core.tests.compiler/src/org/eclipse/jdt/groovy/core/tests/basic/GroovyCompilerTestSuite.java

@@ -77,7 +77,7 @@ public abstract class GroovyCompilerTestSuite {
     protected static final long JDK14 = (58L << 16) + ClassFileConstants.MINOR_VERSION_0;
     protected static final long JDK15 = (59L << 16) + ClassFileConstants.MINOR_VERSION_0;
     protected static final long JDK16 = (60L << 16) + ClassFileConstants.MINOR_VERSION_0;
-    protected static final long JDK17 = (60L << 17) + ClassFileConstants.MINOR_VERSION_0;
+    protected static final long JDK17 = (61L << 16) + ClassFileConstants.MINOR_VERSION_0;
 
     @Parameters(name = "Java {1}")
     public static Iterable<Object[]> params() {
@@ -170,8 +170,12 @@ public String getName() {
 
             @Override
             protected INameEnvironment getNameEnvironment(final String[] testFiles, final String[] classPaths) {
-                this.classpaths = (classPaths == null ? getDefaultClassPaths() : classPaths);
-                return new InMemoryNameEnvironment(testFiles, getClassLibs(false));
+                return getNameEnvironment(testFiles, classPaths, null);
+            }
+
+            protected INameEnvironment getNameEnvironment(final String[] testFiles, final String[] classPaths, final Map<String, String> options) {
+                this.classpaths = (classPaths != null ? classPaths : getDefaultClassPaths());
+                return new InMemoryNameEnvironment(testFiles, getClassLibs(false, options));
             }
 
             private String resolve(final URL jarRef) throws IOException {

base/org.codehaus.groovy25/src/org/codehaus/groovy/antlr/AntlrParserPlugin.java

@@ -795,8 +795,8 @@ protected Expression anonymousInnerClassDef(AST node) {
         ClassNode outerClass = getClassOrScript(oldNode);
         String innerClassName = outerClass.getName() + "$" + (anonymousClassCount(outerClass) + 1);
         if (enumConstantBeingDef) {
-            classNode = new EnumConstantClassNode(outerClass, innerClassName, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
-        } else {
+            classNode = new EnumConstantClassNode(outerClass, innerClassName, Opcodes.ACC_ENUM | Opcodes.ACC_FINAL, ClassHelper.OBJECT_TYPE);
+        } else { // GRECLIPSE edit                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
             classNode = new InnerClassNode(outerClass, innerClassName, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
         }
         ((InnerClassNode) classNode).setAnonymous(true);
@@ -1035,8 +1035,9 @@ protected void enumConstantDef(AST node) {
                 // we have to handle an enum constant with a class overriding
                 // a method in which case we need to configure the inner class
                 innerClass.setSuperClass(classNode.getPlainNodeReference());
+                /* GRECLIPSE edit
                 innerClass.setModifiers(classNode.getModifiers() | Opcodes.ACC_FINAL);
-                // GRECLIPSE add
+                */
                 innerClass.setNameStart(nameStart);
                 innerClass.setNameEnd(nameEnd - 1);
                 // GRECLIPSE end

base/org.codehaus.groovy30/src/org/apache/groovy/parser/antlr4/AstBuilder.java

@@ -1451,7 +1451,9 @@ public ClassNode visitClassDeclaration(ClassDeclarationContext ctx) {
             this.hackMixins(classNode);
 
         } else if (isEnum) {
+            /* GRECLIPSE edit -- EnumHelper#makeEnumNode does this
             classNode.setModifiers(classNode.getModifiers() | Opcodes.ACC_ENUM | Opcodes.ACC_FINAL);
+            */
             classNode.setInterfaces(this.visitTypeList(ctx.is));
             this.initUsingGenerics(classNode);
 
@@ -3657,7 +3659,7 @@ public InnerClassNode visitAnonymousInnerClassDeclaration(AnonymousInnerClassDec
 
         InnerClassNode anonymousInnerClass;
         if (1 == ctx.t) { // anonymous enum
-            anonymousInnerClass = new EnumConstantClassNode(outerClass, innerClassName, superClass.getModifiers() | Opcodes.ACC_FINAL, superClass.getPlainNodeReference());
+            anonymousInnerClass = new EnumConstantClassNode(outerClass, innerClassName, Opcodes.ACC_ENUM | Opcodes.ACC_FINAL, superClass.getPlainNodeReference());
             // and remove the final modifier from classNode to allow the sub class
             superClass.setModifiers(superClass.getModifiers() & ~Opcodes.ACC_FINAL);
         } else { // anonymous inner class

base/org.codehaus.groovy30/src/org/codehaus/groovy/antlr/AntlrParserPlugin.java

@@ -882,8 +882,8 @@ protected Expression anonymousInnerClassDef(AST node) {
         ClassNode outerClass = getClassOrScript(oldNode);
         String innerClassName = outerClass.getName() + "$" + (anonymousClassCount(outerClass) + 1);
         if (enumConstantBeingDef) {
-            classNode = new EnumConstantClassNode(outerClass, innerClassName, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
-        } else {
+            classNode = new EnumConstantClassNode(outerClass, innerClassName, Opcodes.ACC_ENUM | Opcodes.ACC_FINAL, ClassHelper.OBJECT_TYPE);
+        } else { // GRECLIPSE edit                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
             classNode = new InnerClassNode(outerClass, innerClassName, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
         }
         ((InnerClassNode) classNode).setAnonymous(true);
@@ -1123,8 +1123,9 @@ protected void enumConstantDef(AST node) {
                 // we have to handle an enum constant with a class overriding
                 // a method in which case we need to configure the inner class
                 innerClass.setSuperClass(classNode.getPlainNodeReference());
+                /* GRECLIPSE edit
                 innerClass.setModifiers(classNode.getModifiers() | Opcodes.ACC_FINAL);
-                // GRECLIPSE add
+                */
                 innerClass.setNameStart(nameStart);
                 innerClass.setNameEnd(nameEnd - 1);
                 // GRECLIPSE end

base/org.codehaus.groovy40/groovy-parser2.jar

@@ -1515,8 +1515,7 @@ public ClassNode visitClassDeclaration(final ClassDeclarationContext ctx) {
 
         if ((isAnnotation || isEnum) && (isSealed || isNonSealed)) {
             ModifierNode mn = isSealed ? sealedModifierNodeOptional.get() : nonSealedModifierNodeOptional.get();
-            throw createParsingFailedException("modifier `" + mn.getText() + "` is not allowed for " +
-                    (isEnum ? "enum" : "annotation definition"), mn);
+            throw createParsingFailedException("modifier `" + mn.getText() + "` is not allowed for " + (isEnum ? "enum" : "annotation definition"), mn);
         }
 
         boolean hasPermits = asBoolean(ctx.PERMITS());
@@ -1613,7 +1612,9 @@ public ClassNode visitClassDeclaration(final ClassDeclarationContext ctx) {
             this.hackMixins(classNode);
 
         } else if (isEnum) {
+            /* GRECLIPSE edit -- EnumHelper#makeEnumNode does this
             classNode.setModifiers(classNode.getModifiers() | Opcodes.ACC_ENUM | Opcodes.ACC_FINAL);
+            */
             classNode.setInterfaces(this.visitTypeList(ctx.is));
             this.initUsingGenerics(classNode);
 
@@ -3829,7 +3830,7 @@ public InnerClassNode visitAnonymousInnerClassDeclaration(final AnonymousInnerCl
 
         InnerClassNode anonymousInnerClass;
         if (1 == ctx.t) { // anonymous enum
-            anonymousInnerClass = new EnumConstantClassNode(outerClass, innerClassName, superClass.getModifiers() | Opcodes.ACC_FINAL, superClass.getPlainNodeReference());
+            anonymousInnerClass = new EnumConstantClassNode(outerClass, innerClassName, Opcodes.ACC_ENUM | Opcodes.ACC_FINAL, superClass.getPlainNodeReference());
             // and remove the final modifier from classNode to allow the sub class
             superClass.setModifiers(superClass.getModifiers() & ~Opcodes.ACC_FINAL);
         } else { // anonymous inner class

base/org.codehaus.groovy40/src/org/apache/groovy/parser/antlr4/AstBuilder.java

@@ -882,8 +882,8 @@ protected Expression anonymousInnerClassDef(AST node) {
         ClassNode outerClass = getClassOrScript(oldNode);
         String innerClassName = outerClass.getName() + "$" + (anonymousClassCount(outerClass) + 1);
         if (enumConstantBeingDef) {
-            classNode = new EnumConstantClassNode(outerClass, innerClassName, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
-        } else {
+            classNode = new EnumConstantClassNode(outerClass, innerClassName, Opcodes.ACC_ENUM | Opcodes.ACC_FINAL, ClassHelper.OBJECT_TYPE);
+        } else { // GRECLIPSE edit                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
             classNode = new InnerClassNode(outerClass, innerClassName, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
         }
         ((InnerClassNode) classNode).setAnonymous(true);
@@ -1123,8 +1123,9 @@ protected void enumConstantDef(AST node) {
                 // we have to handle an enum constant with a class overriding
                 // a method in which case we need to configure the inner class
                 innerClass.setSuperClass(classNode.getPlainNodeReference());
+                /* GRECLIPSE edit
                 innerClass.setModifiers(classNode.getModifiers() | Opcodes.ACC_FINAL);
-                // GRECLIPSE add
+                */
                 innerClass.setNameStart(nameStart);
                 innerClass.setNameEnd(nameEnd - 1);
                 // GRECLIPSE end

base/org.codehaus.groovy40/src/org/codehaus/groovy/antlr/AntlrParserPlugin.java

@@ -1143,7 +1143,7 @@ private void createTypeDeclarations(ModuleNode moduleNode) {
                 }
 
                 boolean isEnum = classNode.isEnum();
-                configureSuperClass(typeDeclaration, classNode.getSuperClass(), isEnum, isTrait(classNode));
+                if (!isEnum && !isTrait(classNode)) configureSuperClass(typeDeclaration, classNode.getSuperClass());
                 configureSuperInterfaces(typeDeclaration, classNode);
                 typeDeclaration.fields = createFieldDeclarations(classNode, isEnum);
                 typeDeclaration.methods = createConstructorAndMethodDeclarations(classNode, isEnum, typeDeclaration);
@@ -1546,15 +1546,9 @@ private AbstractMethodDeclaration createMethodDeclaration(ClassNode classNode, M
 
         //----------------------------------------------------------------------
 
-        private void configureSuperClass(TypeDeclaration typeDeclaration, ClassNode superclass, boolean isEnum, boolean isTrait) {
-            if ((isEnum && superclass.getName().equals("java.lang.Enum")) || isTrait) {
-                // Don't wire it in, JDT will do it
-                typeDeclaration.superclass = null;
-            } else {
-                // If the start position is 0 the superclass wasn't actually declared, it was added by Groovy
-                if (!(superclass.getStart() == 0 && superclass.equals(ClassHelper.OBJECT_TYPE))) {
-                    typeDeclaration.superclass = createTypeReferenceForClassNode(superclass);
-                }
+        private void configureSuperClass(TypeDeclaration typeDeclaration, ClassNode superclass) {
+            if (!(superclass.getStart() == 0 && superclass.equals(ClassHelper.OBJECT_TYPE))) {
+                typeDeclaration.superclass = createTypeReferenceForClassNode(superclass);
             }
         }
 

base/org.eclipse.jdt.groovy.core/src/org/codehaus/jdt/groovy/internal/compiler/ast/GroovyCompilationUnitDeclaration.java

@@ -167,7 +167,7 @@ This minimal project set should be open in your workspace:
 * org.eclipse.jdt.groovy.core.tests.builder
 * org.eclipse.jdt.groovy.core.tests.compiler
 
-Note: Only one JDT patch should be imported (`org.eclipse.jdt.core`, `org.eclipse.jdt.core.tests.builder`, `org.eclipse.jdt.core.tests.compiler`) and it should be matched to the target platform of your workspace.  For example, the patch in the `/e421` folder is for Eclipse 4.21 (2021-09).
+Note: Only one JDT patch should be imported (`org.eclipse.jdt.core`, `org.eclipse.jdt.core.tests.builder`, `org.eclipse.jdt.core.tests.compiler`) and it should be matched to the target platform of your workspace.  For example, the patch in the `/e422` folder is for Eclipse 4.22 (2021-12).
 
 
 ## Test with Eclipse
@@ -185,14 +185,15 @@ For manual testing and debugging, right-click on the org.codehaus.groovy.eclipse
 
 [Download and install Maven](https://maven.apache.org/).
 
-From the root directory of the repository, execute the following command to build Groovy-Eclipse for Eclipse 4.21 (2021-09).
+From the root directory of the repository, execute the following command to build Groovy-Eclipse for Eclipse 4.22 (2021-12).
 
 	```
-	mvn -Pe4.21 clean install
+	mvn -Pe4.22 clean install
 	```
 
-Replace e4.21 with a different option to build it for another Eclipse version:
+Replace e4.22 with a different option to build it for another Eclipse version:
 
+* e4.21
 * e4.20
 * e4.19
 * e4.18