You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by su...@apache.org on 2026/08/29 14:17:35 UTC

(groovy) branch generics-tck updated (f1fcadc495 -> dc0fd3f307)

This is an automated email from the ASF dual-hosted git repository.

asf-gitbox-commits pushed a change to branch generics-tck
in repository https://gitbox.apache.org/repos/asf/groovy.git


 discard f1fcadc495 Add test suite for Groovy compatibility with Java generics
     new de3bf99259 GROOVY-12319: Add test suite for Groovy compatibility with Java generics
     new dc0fd3f307 GROOVY-12319: Java compatibility: remaining generic type syntax

This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version.  This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:

 * -- * -- B -- O -- O -- O   (f1fcadc495)
            \
             N -- N -- N   refs/heads/generics-tck (dc0fd3f307)

You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.

Any revisions marked "omit" are not gone; other references still
refer to them.  Any revisions marked "discard" are gone forever.

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 src/antlr/GroovyParser.g4                          |  14 +-
 .../apache/groovy/parser/antlr4/AstBuilder.java    |  93 +++-
 .../groovy/ast/expr/ConstructorCallExpression.java |  66 ++-
 .../org/codehaus/groovy/classgen/Verifier.java     |  77 +++
 .../groovy/classgen/asm/BytecodeHelper.java        |  53 +-
 .../codehaus/groovy/control/GenericsVisitor.java   |  25 +-
 .../codehaus/groovy/control/ResolveVisitor.java    |  12 +
 .../transform/stc/StaticTypeCheckingSupport.java   |  23 +-
 .../transform/stc/StaticTypeCheckingVisitor.java   | 219 ++++++--
 .../groovy/transform/stc/TypeCheckingContext.java  |   7 +-
 src/spec/doc/core-operators.adoc                   |   7 +
 src/spec/test/OperatorsTest.groovy                 |  15 +
 src/test/groovy/bugs/Groovy12319.groovy            | 616 +++++++++++++++++++++
 .../generics/GenericsJavaCompatibilityTest.groovy  |  31 +-
 .../groovy/gls/generics/GenericsUsageTest.groovy   |   5 +-
 .../groovy/transform/stc/GenericsSTCTest.groovy    |   7 +-
 16 files changed, 1123 insertions(+), 147 deletions(-)
 create mode 100644 src/test/groovy/bugs/Groovy12319.groovy


(groovy) 02/02: GROOVY-12319: Java compatibility: remaining generic type syntax

Posted by su...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

asf-gitbox-commits pushed a commit to branch generics-tck
in repository https://gitbox.apache.org/repos/asf/groovy.git

commit dc0fd3f3077eedad82dd445004769dace5158c18
Author: Daniel Sun <su...@apache.org>
AuthorDate: Sat Aug 29 14:14:13 2026 +0000

    GROOVY-12319: Java compatibility: remaining generic type syntax
    
    Accept diamond on anonymous classes, qualified parameterized inner
    types (Outer<T>.Inner<U>), and explicit constructor type arguments
    on new, this() and super().
---
 src/antlr/GroovyParser.g4                          |  14 +-
 .../apache/groovy/parser/antlr4/AstBuilder.java    |  93 +++-
 .../groovy/ast/expr/ConstructorCallExpression.java |  66 ++-
 .../org/codehaus/groovy/classgen/Verifier.java     |  77 +++
 .../groovy/classgen/asm/BytecodeHelper.java        |  53 +-
 .../codehaus/groovy/control/GenericsVisitor.java   |  25 +-
 .../codehaus/groovy/control/ResolveVisitor.java    |  12 +
 .../transform/stc/StaticTypeCheckingSupport.java   |  23 +-
 .../transform/stc/StaticTypeCheckingVisitor.java   | 219 ++++++--
 .../groovy/transform/stc/TypeCheckingContext.java  |   7 +-
 src/spec/doc/core-operators.adoc                   |   7 +
 src/spec/test/OperatorsTest.groovy                 |  15 +
 src/test/groovy/bugs/Groovy12319.groovy            | 616 +++++++++++++++++++++
 .../generics/GenericsJavaCompatibilityTest.groovy  |  31 +-
 .../groovy/gls/generics/GenericsUsageTest.groovy   |   5 +-
 .../groovy/transform/stc/GenericsSTCTest.groovy    |   7 +-
 16 files changed, 1123 insertions(+), 147 deletions(-)

diff --git a/src/antlr/GroovyParser.g4 b/src/antlr/GroovyParser.g4
index 2e132403c1..43f7ad6353 100644
--- a/src/antlr/GroovyParser.g4
+++ b/src/antlr/GroovyParser.g4
@@ -349,8 +349,9 @@ primitiveType
     :   BuiltInPrimitiveType
     ;
 
+// GROOVY-12319: JLS 4.5 "rare" types (Outer<T>.Inner after the outer type arguments)
 referenceType
-    :   qualifiedClassName typeArguments?
+    :   qualifiedClassName (typeArguments (DOT identifier typeArguments?)*)?
     ;
 
 matchingType // see: instanceof / !instanceof type patterns (JEP 394)
@@ -376,7 +377,7 @@ options { baseContext = type; }
 
 standardClassOrInterfaceType
 options { baseContext = referenceType; }
-    :   qualifiedStandardClassName typeArguments?
+    :   qualifiedStandardClassName (typeArguments (DOT className typeArguments?)*)?
     ;
 
 typeArguments
@@ -992,7 +993,7 @@ pathElement returns [int t]
     :   nls
         (
             DOT nls
-            (   NEW creator[1]
+            (   NEW nonWildcardTypeArguments? creator[1]  // GROOVY-12319: outer.new <T>Inner(...)
                 { $t = 6; }
             |
                 // AT: foo.@bar selects the field (or attribute), not property
@@ -1088,9 +1089,10 @@ primary
         identifier typeArguments?                                                           #identifierPrmrAlt
     |   literal                                                                             #literalPrmrAlt
     |   gstring                                                                             #gstringPrmrAlt
-    |   NEW nls creator[0]                                                                  #newPrmrAlt
-    |   THIS                                                                                #thisPrmrAlt
-    |   SUPER                                                                               #superPrmrAlt
+    // GROOVY-12319: JLS 15.9 / 8.8.7.1 constructor type arguments (new <T>C(), <T>this(), <T>super())
+    |   NEW nls nonWildcardTypeArguments? creator[0]                                        #newPrmrAlt
+    |   nonWildcardTypeArguments? THIS                                                      #thisPrmrAlt
+    |   nonWildcardTypeArguments? SUPER                                                     #superPrmrAlt
     |   parExpression                                                                       #parenPrmrAlt
     |   closureOrLambdaExpression                                                           #closureOrLambdaExpressionPrmrAlt
     |   list                                                                                #listPrmrAlt
diff --git a/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java b/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
index 70fef04b72..4bfcddd631 100644
--- a/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
+++ b/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
@@ -2878,6 +2878,9 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
         } else if (asBoolean(ctx.creator())) {
             CreatorContext creatorContext = ctx.creator();
             creatorContext.putNodeMetaData(ENCLOSING_INSTANCE_EXPRESSION, baseExpr);
+            if (asBoolean(ctx.nonWildcardTypeArguments())) {
+                creatorContext.putNodeMetaData(PATH_EXPRESSION_BASE_EXPR_GENERICS_TYPES, this.visitNonWildcardTypeArguments(ctx.nonWildcardTypeArguments()));
+            }
             return configureAST(this.visitCreator(creatorContext), ctx);
         } else if (asBoolean(ctx.indexPropertyArgs())) { // e.g. list[1, 3, 5]
             Tuple2<Token, Expression> tuple = this.visitIndexPropertyArgs(ctx.indexPropertyArgs());
@@ -2969,14 +2972,14 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
                                 ctx);
                     }
 
-                    return configureAST(
-                            new ConstructorCallExpression(
-                                    SUPER_STR.equals(baseExprText)
-                                            ? ClassNode.SUPER
-                                            : ClassNode.THIS,
-                                    argumentsExpr
-                            ),
-                            ctx);
+                    ConstructorCallExpression constructorCallExpression = new ConstructorCallExpression(
+                            SUPER_STR.equals(baseExprText)
+                                    ? ClassNode.SUPER
+                                    : ClassNode.THIS,
+                            argumentsExpr
+                    );
+                    constructorCallExpression.setGenericsTypes(baseExpr.getNodeMetaData(PATH_EXPRESSION_BASE_EXPR_GENERICS_TYPES));
+                    return configureAST(constructorCallExpression, ctx);
                 }
 
                 MethodCallExpression methodCallExpression = this.createMethodCallExpression(baseExpr, argumentsExpr);
@@ -3861,17 +3864,28 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
 
     @Override
     public Expression visitNewPrmrAlt(final NewPrmrAltContext ctx) {
+        if (asBoolean(ctx.nonWildcardTypeArguments())) {
+            ctx.creator().putNodeMetaData(PATH_EXPRESSION_BASE_EXPR_GENERICS_TYPES, this.visitNonWildcardTypeArguments(ctx.nonWildcardTypeArguments()));
+        }
         return configureAST(this.visitCreator(ctx.creator()), ctx);
     }
 
     @Override
     public VariableExpression visitThisPrmrAlt(final ThisPrmrAltContext ctx) {
-        return configureAST(new VariableExpression(ctx.THIS().getText()), ctx);
+        VariableExpression varExpr = configureAST(new VariableExpression(ctx.THIS().getText()), ctx);
+        if (asBoolean(ctx.nonWildcardTypeArguments())) {
+            varExpr.putNodeMetaData(PATH_EXPRESSION_BASE_EXPR_GENERICS_TYPES, this.visitNonWildcardTypeArguments(ctx.nonWildcardTypeArguments()));
+        }
+        return varExpr;
     }
 
     @Override
     public VariableExpression visitSuperPrmrAlt(final SuperPrmrAltContext ctx) {
-        return configureAST(new VariableExpression(ctx.SUPER().getText()), ctx);
+        VariableExpression varExpr = configureAST(new VariableExpression(ctx.SUPER().getText()), ctx);
+        if (asBoolean(ctx.nonWildcardTypeArguments())) {
+            varExpr.putNodeMetaData(PATH_EXPRESSION_BASE_EXPR_GENERICS_TYPES, this.visitNonWildcardTypeArguments(ctx.nonWildcardTypeArguments()));
+        }
+        return varExpr;
     }
 
     // } primary ---------------------------------------------------------------
@@ -3883,6 +3897,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
         if (asBoolean(ctx.arguments())) { // create instance of class
             Expression arguments = this.visitArguments(ctx.arguments());
             Expression enclosingInstanceExpression = ctx.getNodeMetaData(ENCLOSING_INSTANCE_EXPRESSION);
+            GenericsType[] constructorGenerics = ctx.getNodeMetaData(PATH_EXPRESSION_BASE_EXPR_GENERICS_TYPES);
 
             if (enclosingInstanceExpression != null) {
                 if (arguments instanceof ArgumentListExpression) {
@@ -3910,10 +3925,16 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
 
                 ConstructorCallExpression constructorCallExpression = new ConstructorCallExpression(anonymousInnerClassNode, arguments);
                 constructorCallExpression.setUsingAnonymousInnerClass(true);
+                if (constructorGenerics != null) {
+                    constructorCallExpression.setGenericsTypes(constructorGenerics);
+                }
                 return configureAST(constructorCallExpression, ctx);
             }
 
             ConstructorCallExpression constructorCallExpression = new ConstructorCallExpression(classNode, arguments);
+            if (constructorGenerics != null) {
+                constructorCallExpression.setGenericsTypes(constructorGenerics);
+            }
             return configureAST(constructorCallExpression, ctx);
         }
 
@@ -4647,29 +4668,43 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
 
     @Override
     public ClassNode visitReferenceType(final ReferenceTypeContext ctx) {
-        ClassNode classNode;
-        if (asBoolean(ctx.qualifiedClassName())) {
-            if (isTrue(ctx, IS_INSIDE_INSTANCEOF_EXPR)) {
-                ctx.qualifiedClassName().putNodeMetaData(IS_INSIDE_INSTANCEOF_EXPR, Boolean.TRUE);
-            }
-            classNode = this.visitQualifiedClassName(ctx.qualifiedClassName());
-        } else {
-            if (isTrue(ctx, IS_INSIDE_INSTANCEOF_EXPR)) {
-                ctx.qualifiedStandardClassName().putNodeMetaData(IS_INSIDE_INSTANCEOF_EXPR, Boolean.TRUE);
+        ClassNode classNode = null;
+        for (int i = 0, n = ctx.getChildCount(); i < n; i += 1) {
+            ParseTree child = ctx.getChild(i);
+            if (child instanceof QualifiedClassNameContext qcn) {
+                if (isTrue(ctx, IS_INSIDE_INSTANCEOF_EXPR)) {
+                    qcn.putNodeMetaData(IS_INSIDE_INSTANCEOF_EXPR, Boolean.TRUE);
+                }
+                classNode = this.visitQualifiedClassName(qcn);
+            } else if (child instanceof QualifiedStandardClassNameContext qscn) {
+                if (isTrue(ctx, IS_INSIDE_INSTANCEOF_EXPR)) {
+                    qscn.putNodeMetaData(IS_INSIDE_INSTANCEOF_EXPR, Boolean.TRUE);
+                }
+                classNode = this.visitQualifiedStandardClassName(qscn);
+            } else if (child instanceof TypeArgumentsContext tac) {
+                GenericsType[] generics = this.visitTypeArguments(tac);
+                classNode.setGenericsTypes(generics);
+                rejectParameterizedInstanceof(ctx, classNode, generics);
+            } else if (child instanceof IdentifierContext || child instanceof ClassNameContext) {
+                ClassNode outer = classNode;
+                ClassNode inner = ClassHelper.makeWithoutCaching(outer.getName() + '.' + child.getText());
+                if (!isTrue(ctx, IS_INSIDE_INSTANCEOF_EXPR)) {
+                    inner = this.proxyClassNode(inner);
+                }
+                if (outer.getGenericsTypes() != null) {
+                    inner.putNodeMetaData("outer.class", outer); // GROOVY-10646, GROOVY-12319
+                }
+                classNode = configureAST(inner, (GroovyParserRuleContext) child);
             }
-            classNode = this.visitQualifiedStandardClassName(ctx.qualifiedStandardClassName());
         }
+        return configureAST(classNode, ctx);
+    }
 
-        if (asBoolean(ctx.typeArguments())) {
-            GenericsType[] generics = this.visitTypeArguments(ctx.typeArguments());
-            classNode.setGenericsTypes(generics);
-            if (isTrue(ctx, IS_INSIDE_INSTANCEOF_EXPR) && Arrays.stream(generics).anyMatch(gt ->
-                    !gt.isWildcard() || asBoolean(gt.getLowerBound()) || ArrayGroovyMethods.asBoolean(gt.getUpperBounds()))) { // GROOVY-11585
-                throw this.createParsingFailedException("Cannot perform instanceof check against parameterized type " + classNode, ctx);
-            }
+    private void rejectParameterizedInstanceof(final ReferenceTypeContext ctx, final ClassNode classNode, final GenericsType[] generics) {
+        if (isTrue(ctx, IS_INSIDE_INSTANCEOF_EXPR) && Arrays.stream(generics).anyMatch(gt ->
+                !gt.isWildcard() || asBoolean(gt.getLowerBound()) || ArrayGroovyMethods.asBoolean(gt.getUpperBounds()))) { // GROOVY-11585
+            throw this.createParsingFailedException("Cannot perform instanceof check against parameterized type " + classNode, ctx);
         }
-
-        return configureAST(classNode, ctx);
     }
 
     @Override
diff --git a/src/main/java/org/codehaus/groovy/ast/expr/ConstructorCallExpression.java b/src/main/java/org/codehaus/groovy/ast/expr/ConstructorCallExpression.java
index 86bcbcb5af..f1b10ee43a 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/ConstructorCallExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/ConstructorCallExpression.java
@@ -20,6 +20,7 @@ package org.codehaus.groovy.ast.expr;
 
 import org.codehaus.groovy.ast.ASTNode;
 import org.codehaus.groovy.ast.ClassNode;
+import org.codehaus.groovy.ast.GenericsType;
 import org.codehaus.groovy.ast.GroovyCodeVisitor;
 
 /**
@@ -28,6 +29,8 @@ import org.codehaus.groovy.ast.GroovyCodeVisitor;
  * as well as special constructor calls like {@code this()} and {@code super()} calls within constructors.
  * The constructor is identified by the type being constructed, and the arguments are wrapped in a {@link TupleExpression}.
  * May optionally use an anonymous inner class.
+ * Explicit constructor type arguments ({@code new <T>Box(t)}, {@code <T>this(t)}, {@code <T>super(t)})
+ * are stored separately from the constructed type's own type arguments.
  * 
  * @see {@link MethodCall} for the method interface this class implements
  * @see {@link TupleExpression} for argument representation
@@ -44,6 +47,10 @@ public class ConstructorCallExpression extends Expression implements MethodCall
      * Whether this constructor call uses an anonymous inner class declaration.
      */
     private boolean usesAnonymousInnerClass;
+    /**
+     * Explicit constructor type arguments, e.g. {@code new <String>Box("x")} or {@code <T>super(t)}.
+     */
+    private GenericsType[] genericsTypes;
 
     /**
      * Creates a constructor call expression.
@@ -71,6 +78,7 @@ public class ConstructorCallExpression extends Expression implements MethodCall
     public Expression transformExpression(ExpressionTransformer transformer) {
         ConstructorCallExpression answer = new ConstructorCallExpression(getType(), transformer.transform(arguments));
         answer.setUsingAnonymousInnerClass(isUsingAnonymousInnerClass());
+        answer.setGenericsTypes(genericsTypes);
         answer.setSourcePosition(this);
         answer.copyNodeMetaData(this);
         return answer;
@@ -98,15 +106,63 @@ public class ConstructorCallExpression extends Expression implements MethodCall
 
     @Override
     public String getText() {
-        String text;
+        StringBuilder builder = new StringBuilder(64);
         if (isSuperCall()) {
-            text = "super ";
+            appendTypeArguments(builder);
+            builder.append("super ");
         } else if (isThisCall()) {
-            text = "this ";
+            appendTypeArguments(builder);
+            builder.append("this ");
         } else {
-            text = "new " + getType().toString(false);
+            builder.append("new ");
+            appendTypeArguments(builder);
+            builder.append(getType().toString(false));
+        }
+        return builder.append(getArguments().getText()).toString();
+    }
+
+    private void appendTypeArguments(final StringBuilder builder) {
+        if (!isUsingGenerics()) return;
+        builder.append('<');
+        boolean first = true;
+        for (GenericsType t : genericsTypes) {
+            if (!first) builder.append(", ");
+            else first = false;
+            builder.append(t);
         }
-        return text + getArguments().getText();
+        builder.append('>');
+    }
+
+    /**
+     * Returns the explicit constructor type arguments, if specified.
+     * Used for generic constructor invocations such as {@code new <String>Box("x")},
+     * {@code <T>this(t)} and {@code <T>super(t)}.
+     *
+     * @return an array of {@link GenericsType} parameters, or {@code null} if none are specified
+     * @since 6.0.0
+     */
+    public GenericsType[] getGenericsTypes() {
+        return genericsTypes;
+    }
+
+    /**
+     * Sets the explicit constructor type arguments.
+     *
+     * @param genericsTypes an array of {@link GenericsType} parameters; may be {@code null}
+     * @since 6.0.0
+     */
+    public void setGenericsTypes(final GenericsType[] genericsTypes) {
+        this.genericsTypes = genericsTypes;
+    }
+
+    /**
+     * Indicates whether explicit constructor type arguments are specified.
+     *
+     * @return {@code true} if type arguments are present; {@code false} otherwise
+     * @since 6.0.0
+     */
+    public boolean isUsingGenerics() {
+        return genericsTypes != null && genericsTypes.length > 0;
     }
 
     /**
diff --git a/src/main/java/org/codehaus/groovy/classgen/Verifier.java b/src/main/java/org/codehaus/groovy/classgen/Verifier.java
index 0d73045355..03ba975410 100644
--- a/src/main/java/org/codehaus/groovy/classgen/Verifier.java
+++ b/src/main/java/org/codehaus/groovy/classgen/Verifier.java
@@ -1784,6 +1784,13 @@ public class Verifier implements GroovyClassVisitor, Opcodes {
         ClassNode sc = classNode.getUnresolvedSuperClass(false);
         if (sc != null) {
             Map<String, ClassNode> genericsSpec = createGenericsSpec(sc, oldGenericsSpec);
+            if (genericsSpec.isEmpty() && classNode instanceof InnerClassNode && ((InnerClassNode) classNode).isAnonymous() && sc.redirect().getGenericsTypes() != null) {
+                // GROOVY-12319: diamond AIC has an empty type-argument list; recover T from overrides for bridges
+                genericsSpec = inferGenericsSpecFromMethods(classNode, sc, oldGenericsSpec);
+                if (!genericsSpec.isEmpty()) {
+                    updateTypeGenerics(sc, genericsSpec);
+                }
+            }
             List<MethodNode> scMethods = sc.getMethods();
             // add bridge methods in original class for overridden methods with changed signature
             storeMissingCovariantMethods(declaredMethods, methodsToAdd, genericsSpec, scMethods);
@@ -1808,11 +1815,81 @@ public class Verifier implements GroovyClassVisitor, Opcodes {
         for (ClassNode anInterface : classNode.getInterfaces()) {
             List<MethodNode> ifaceMethods = anInterface.getMethods();
             Map<String, ClassNode> genericsSpec = createGenericsSpec(anInterface, oldGenericsSpec);
+            if (genericsSpec.isEmpty() && classNode instanceof InnerClassNode && ((InnerClassNode) classNode).isAnonymous() && anInterface.redirect().getGenericsTypes() != null) {
+                // GROOVY-12319: diamond AIC implementing a generic interface
+                genericsSpec = inferGenericsSpecFromMethods(classNode, anInterface, oldGenericsSpec);
+                if (!genericsSpec.isEmpty()) {
+                    updateTypeGenerics(anInterface, genericsSpec);
+                }
+            }
             storeMissingCovariantMethods(declaredMethods, methodsToAdd, genericsSpec, ifaceMethods);
             addCovariantMethods(anInterface, declaredMethods, interfaceMethods, methodsToAdd, genericsSpec);
         }
     }
 
+    private static Map<String, ClassNode> inferGenericsSpecFromMethods(final ClassNode classNode, final ClassNode superType, final Map<String, ClassNode> oldSpec) {
+        Map<String, ClassNode> spec = new HashMap<>(oldSpec);
+        GenericsType[] rgt = superType.redirect().getGenericsTypes();
+        if (rgt == null || rgt.length == 0) return spec;
+
+        Map<String, List<MethodNode>> declaredByName = new HashMap<>();
+        for (MethodNode declaredMethod : classNode.getMethods()) {
+            if (declaredMethod.isStatic() || declaredMethod.isPrivate()) continue;
+            declaredByName.computeIfAbsent(declaredMethod.getName(), k -> new ArrayList<>()).add(declaredMethod);
+        }
+        for (MethodNode superMethod : superType.getMethods()) {
+            if (superMethod.isStatic() || superMethod.isPrivate()) continue;
+            List<MethodNode> candidates = declaredByName.get(superMethod.getName());
+            if (candidates == null) continue;
+            for (MethodNode declaredMethod : candidates) {
+                if (declaredMethod.getParameters().length != superMethod.getParameters().length) continue;
+
+                Parameter[] sp = superMethod.getParameters();
+                Parameter[] dp = declaredMethod.getParameters();
+                for (int i = 0; i < sp.length; i += 1) {
+                    extractGenerics(sp[i].getType(), dp[i].getType(), spec);
+                }
+                extractGenerics(superMethod.getReturnType(), declaredMethod.getReturnType(), spec);
+            }
+        }
+        return spec;
+    }
+
+    private static void extractGenerics(final ClassNode typeWithGenerics, final ClassNode actualType, final Map<String, ClassNode> spec) {
+        if (typeWithGenerics.isGenericsPlaceHolder()) {
+            if (typeWithGenerics.getGenericsTypes() != null && typeWithGenerics.getGenericsTypes().length > 0) {
+                spec.putIfAbsent(typeWithGenerics.getGenericsTypes()[0].getName(), actualType);
+            } else {
+                spec.putIfAbsent(typeWithGenerics.getUnresolvedName(), actualType);
+            }
+        } else if (typeWithGenerics.getGenericsTypes() != null && actualType.getGenericsTypes() != null) {
+            GenericsType[] tgt = typeWithGenerics.getGenericsTypes();
+            GenericsType[] agt = actualType.getGenericsTypes();
+            for (int i = 0; i < Math.min(tgt.length, agt.length); i += 1) {
+                if (tgt[i].isPlaceholder()) {
+                    spec.putIfAbsent(tgt[i].getName(), agt[i].getType());
+                } else if (tgt[i].getType() != null && agt[i].getType() != null) {
+                    extractGenerics(tgt[i].getType(), agt[i].getType(), spec);
+                }
+            }
+        }
+    }
+
+    private static void updateTypeGenerics(final ClassNode type, final Map<String, ClassNode> genericsSpec) {
+        GenericsType[] rgt = type.redirect().getGenericsTypes();
+        if (rgt == null || rgt.length == 0) return;
+        GenericsType[] newGt = new GenericsType[rgt.length];
+        for (int i = 0; i < rgt.length; i += 1) {
+            ClassNode resolved = genericsSpec.get(rgt[i].getName());
+            if (resolved == null) {
+                resolved = rgt[i].getUpperBounds() != null && rgt[i].getUpperBounds().length > 0
+                        ? rgt[i].getUpperBounds()[0] : ClassHelper.OBJECT_TYPE;
+            }
+            newGt[i] = new GenericsType(resolved);
+        }
+        type.setGenericsTypes(newGt);
+    }
+
     private static boolean isPossibleOverride(final MethodNode methodNode) {
         return (methodNode.getModifiers() & (ACC_BRIDGE | ACC_PRIVATE | ACC_STATIC)) == 0;
     }
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java b/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java
index 1187065a13..d4a850d6e6 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java
@@ -337,7 +337,10 @@ public class BytecodeHelper {
     }
 
     private static boolean hasGenerics(ClassNode type) {
-        return type.isArray() ? hasGenerics(type.getComponentType()) : type.getGenericsTypes() != null;
+        if (type.isArray()) return hasGenerics(type.getComponentType());
+        if (type.getGenericsTypes() != null && type.getGenericsTypes().length > 0) return true;
+        ClassNode outer = type.getNodeMetaData("outer.class");
+        return outer != null && hasGenerics(outer);
     }
 
     /**
@@ -393,18 +396,13 @@ public class BytecodeHelper {
     public static String getTypeGenericsSignature(ClassNode node) {
         if (!usesGenericsInTypeSignature(node)) return null;
         StringBuilder ret = new StringBuilder(100);
-        ret.append(getTypeDescription(node.getPlainNodeReference(), false));
-        addSubTypes(ret, node.getGenericsTypes(), "<", ">");
+        writeParameterizedClass(ret, node);
         ret.append(";");
-
         return ret.toString();
     }
 
     private static boolean usesGenericsInTypeSignature(ClassNode node) {
-        if (!node.isUsingGenerics()) return false;
-        if (hasGenerics(node)) return true;
-
-        return false;
+        return hasGenerics(node);
     }
 
     /**
@@ -429,7 +427,7 @@ public class BytecodeHelper {
     }
 
     private static void getGenericsTypeSpec(StringBuilder ret, GenericsType[] genericsTypes) {
-        if (genericsTypes == null) return;
+        if (genericsTypes == null || genericsTypes.length == 0) return;
         ret.append('<');
         for (GenericsType genericsType : genericsTypes) {
             String name = genericsType.getName();
@@ -447,8 +445,7 @@ public class BytecodeHelper {
      * @return the bounds signature, or {@code null} if none is needed
      */
     public static String getGenericsBounds(ClassNode type) {
-        GenericsType[] genericsTypes = type.getGenericsTypes();
-        if (genericsTypes == null) return null;
+        if (!hasGenerics(type) && (type.getGenericsTypes() == null || type.getGenericsTypes().length == 0)) return null;
         StringBuilder ret = new StringBuilder(100);
         if (type.isGenericsPlaceHolder()) {
             addSubTypes(ret, type.getGenericsTypes(), "", "");
@@ -466,12 +463,41 @@ public class BytecodeHelper {
             ret.append(printType.getGenericsTypes()[0].getName());
             ret.append(";");
         } else {
-            ret.append(getTypeDescription(printType, false));
-            addSubTypes(ret, printType.getGenericsTypes(), "<", ">");
+            writeParameterizedClass(ret, printType);
             if (!isPrimitiveType(printType)) ret.append(";");
         }
     }
 
+    /**
+     * Writes a class type and its type arguments, using the JLS 4.5 nested form
+     * {@code LOuter&lt;...&gt;.Inner&lt;...&gt;} when {@code outer.class} metadata is present.
+     */
+    private static void writeParameterizedClass(StringBuilder ret, ClassNode printType) {
+        ClassNode owner = printType.getNodeMetaData("outer.class");
+        if (owner != null) {
+            writeParameterizedClass(ret, owner);
+            ret.append('.');
+            ret.append(innerClassSimpleName(printType, owner));
+            addSubTypes(ret, printType.getGenericsTypes(), "<", ">");
+            return;
+        }
+        ret.append(getTypeDescription(printType, false));
+        addSubTypes(ret, printType.getGenericsTypes(), "<", ">");
+    }
+
+    private static String innerClassSimpleName(final ClassNode inner, final ClassNode owner) {
+        String innerName = inner.getName();
+        String ownerName = owner.getName();
+        if (innerName.startsWith(ownerName) && innerName.length() > ownerName.length()) {
+            char sep = innerName.charAt(ownerName.length());
+            if (sep == '.' || sep == '$') {
+                return innerName.substring(ownerName.length() + 1).replace('$', '.');
+            }
+        }
+        int dot = Math.max(innerName.lastIndexOf('.'), innerName.lastIndexOf('$'));
+        return dot < 0 ? innerName : innerName.substring(dot + 1);
+    }
+
     private static void writeGenericsBounds(StringBuilder ret, GenericsType type, boolean writeInterfaceMarker) {
         if (type.getUpperBounds() != null) {
             ClassNode[] bounds = type.getUpperBounds();
@@ -487,6 +513,7 @@ public class BytecodeHelper {
 
     private static void addSubTypes(StringBuilder ret, GenericsType[] types, String start, String end) {
         if (types == null) return;
+        if (types.length == 0 && "<".equals(start)) return;
         ret.append(start);
         for (GenericsType type : types) {
             if (type.getType().isArray()) {
diff --git a/src/main/java/org/codehaus/groovy/control/GenericsVisitor.java b/src/main/java/org/codehaus/groovy/control/GenericsVisitor.java
index 2c133d69ce..49c5915546 100644
--- a/src/main/java/org/codehaus/groovy/control/GenericsVisitor.java
+++ b/src/main/java/org/codehaus/groovy/control/GenericsVisitor.java
@@ -82,7 +82,7 @@ public class GenericsVisitor extends ClassCodeVisitorSupport {
         boolean isAIC = node instanceof InnerClassNode && ((InnerClassNode) node).isAnonymous();
         checkGenericsUsage(sc, sc.redirect(), isAIC ? Boolean.TRUE : null);
         for (ClassNode face : node.getInterfaces()) {
-            checkGenericsUsage(face);
+            checkGenericsUsage(face, face.redirect(), isAIC ? Boolean.TRUE : null);
         }
 
         visitObjectInitializerStatements(node);
@@ -130,6 +130,12 @@ public class GenericsVisitor extends ClassCodeVisitorSupport {
         boolean isAIC = type instanceof InnerClassNode
                 && ((InnerClassNode) type).isAnonymous();
         checkGenericsUsage(type, type.redirect(), isAIC);
+        if (expression.isUsingGenerics()) {
+            ClassNode created = isAIC ? type.getUnresolvedSuperClass(false) : type;
+            if (created != null && created.getGenericsTypes() != null && created.getGenericsTypes().length == 0) {
+                addError("Cannot use diamond <> together with constructor type arguments", expression);
+            }
+        }
 
         super.visitConstructorCallExpression(expression);
     }
@@ -215,18 +221,13 @@ public class GenericsVisitor extends ClassCodeVisitorSupport {
         }
         // parameterize a type by using all the parameters only
         if (cnTypes.length != rnTypes.length) {
-            if (Boolean.FALSE.equals(isAIC) && cnTypes.length == 0) {
-                return; // allow Diamond for non-AIC cases from CCE
+            if (isAIC != null && cnTypes.length == 0) {
+                return; // diamond on constructor calls, including anonymous classes (GROOVY-12319 / JEP 213)
             }
-            String message;
-            if (Boolean.TRUE.equals(isAIC) && cnTypes.length == 0) {
-                message = "Cannot use diamond <> with anonymous inner classes";
-            } else {
-                message = "The class " + cn.toString(false) + " (supplied with " + plural("type parameter", cnTypes.length) +
-                        ") refers to the class " + rn.toString(false) + " which takes " + plural("parameter", rnTypes.length);
-                if (cnTypes.length == 0) {
-                    message += " (invalid Diamond <> usage?)";
-                }
+            String message = "The class " + cn.toString(false) + " (supplied with " + plural("type parameter", cnTypes.length) +
+                    ") refers to the class " + rn.toString(false) + " which takes " + plural("parameter", rnTypes.length);
+            if (cnTypes.length == 0) {
+                message += " (invalid Diamond <> usage?)";
             }
             addError(message, cn);
             return;
diff --git a/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java b/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
index 78a4a88db0..432cad6273 100644
--- a/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
+++ b/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
@@ -420,6 +420,11 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
         if (type.isRedirectNode() || !type.isPrimaryClassNode()) {
             visitTypeAnnotations(type); // JSR 308 support
         }
+        ClassNode oc = type.getNodeMetaData("outer.class"); // GROOVY-10646, GROOVY-12319: Outer<T>.Inner
+        if (oc != null) {
+            resolveOrFail(oc, msg, node, preferImports);
+            resolveGenericsTypes(oc.getGenericsTypes());
+        }
         if (preferImports && !type.isResolved() && !type.isPrimaryClassNode()) {
             resolveGenericsTypes(type.getGenericsTypes());
             if (resolveAliasFromModule(type)) return;
@@ -483,6 +488,13 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
     protected boolean resolve(final ClassNode type, final boolean testModuleImports, final boolean testDefaultImports, final boolean testStaticInnerClasses) {
         GenericsType[] genericsTypes = type.getGenericsTypes();
         resolveGenericsTypes(genericsTypes);
+        ClassNode oc = type.getNodeMetaData("outer.class");
+        if (oc != null) {
+            if (!resolve(oc, testModuleImports, testDefaultImports, testStaticInnerClasses)) {
+                return false;
+            }
+            resolveGenericsTypes(oc.getGenericsTypes());
+        }
 
         if (type.isPrimaryClassNode()) return true;
         if (type.isArray()) {
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
index bf6d37f088..05216a6f36 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
@@ -2078,6 +2078,9 @@ public abstract class StaticTypeCheckingSupport {
         }
 
         GenericsType[] gt = type.getGenericsTypes();
+        if (gt == null && type.isGenericsPlaceHolder()) {
+            gt = new GenericsType[]{type.asGenericsType()};
+        }
         if (asBoolean(spec)) {
             gt = applyGenericsContext(ctx, spec, gt);
         }
@@ -2087,16 +2090,18 @@ public abstract class StaticTypeCheckingSupport {
             return cn;
         }
 
-        if (!gt[0].isPlaceholder()) { // convert T to Type or Type<...>
-            return getCombinedBoundType(gt[0]);
-        }
+        if (gt != null && gt.length > 0) {
+            if (!gt[0].isPlaceholder()) { // convert T to Type or Type<...>
+                return getCombinedBoundType(gt[0]);
+            }
 
-        if (type.getGenericsTypes()[0] != gt[0]) { // convert T to X
-            ClassNode cn = make(gt[0].getName()) , erasure = getCombinedBoundType(gt[0]).redirect();
-            cn.setGenericsPlaceHolder(true);
-            cn.setGenericsTypes(gt);
-            cn.setRedirect(erasure);
-            return cn;
+            if (type.getGenericsTypes() == null || type.getGenericsTypes()[0] != gt[0]) { // convert T to X
+                ClassNode cn = make(gt[0].getName()), erasure = getCombinedBoundType(gt[0]).redirect();
+                cn.setGenericsPlaceHolder(true);
+                cn.setGenericsTypes(gt);
+                cn.setRedirect(erasure);
+                return cn;
+            }
         }
 
         return type; // nothing to do
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
index ac48070d09..5fb1f253a4 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -567,14 +567,20 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
             typeCheckingContext.pushEnclosingClassNode(node);
             Set<MethodNode> oldSet = typeCheckingContext.alreadyVisitedMethods;
             typeCheckingContext.alreadyVisitedMethods = new LinkedHashSet<>();
-
-            doWithTypeCheckingExtensions(node, super::visitClass);
-            node.getInnerClasses().forEachRemaining(this::visitClass);
-
-            typeCheckingContext.alreadyVisitedMethods = oldSet;
-            typeCheckingContext.popEnclosingClassNode();
-            if (type != null) {
-                typeCheckingContext.popErrorCollector();
+            boolean oldStatic = typeCheckingContext.isInStaticContext;
+            if (node instanceof InnerClassNode && ((InnerClassNode) node).isAnonymous()) {
+                typeCheckingContext.isInStaticContext = false; // AIC body is an instance context
+            }
+            try {
+                doWithTypeCheckingExtensions(node, super::visitClass);
+                node.getInnerClasses().forEachRemaining(this::visitClass);
+            } finally {
+                typeCheckingContext.isInStaticContext = oldStatic;
+                typeCheckingContext.alreadyVisitedMethods = oldSet;
+                typeCheckingContext.popEnclosingClassNode();
+                if (type != null) {
+                    typeCheckingContext.popErrorCollector();
+                }
             }
 
             node.putNodeMetaData(INFERRED_TYPE, node);
@@ -1412,10 +1418,17 @@ out:    if ((samParameterTypes.length == 1 && isOrImplements(samParameterTypes[0
      */
     protected void inferDiamondType(final ConstructorCallExpression cce, final ClassNode lType) {
         ClassNode cceType = cce.getType(), inferredType = lType;
+        boolean isAIC = cce.isUsingAnonymousInnerClass();
+        if (isAIC) {
+            cceType = diamondTargetOfAnonymousClass(cce.getType());
+        }
         // check if constructor call expression makes use of the diamond operator
         if (cceType.getGenericsTypes() != null && cceType.getGenericsTypes().length == 0) {
             ArgumentListExpression argumentList = InvocationWriter.makeArgumentList(cce.getArguments());
             ConstructorNode constructor = cce.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
+            if (isAIC && constructor != null && constructor.getDeclaringClass() != cceType.redirect()) {
+                constructor = matchingConstructor(cceType.redirect(), argumentList.getExpressions().size());
+            }
             if (!argumentList.getExpressions().isEmpty() && constructor != null) {
                 ClassNode type = GenericsUtils.parameterizeType(cceType, cceType);
                 type = inferReturnTypeGenerics(type, constructor, argumentList);
@@ -1442,8 +1455,35 @@ out:    if ((samParameterTypes.length == 1 && isOrImplements(samParameterTypes[0
                 inferredType = getCombinedBoundType(inferredType.getGenericsTypes()[0]);
             }
             adjustGenerics(inferredType, cceType);
-            storeType(cce, cceType);
+            storeType(cce, isAIC ? cce.getType() : cceType);
+        }
+    }
+
+    /**
+     * Diamond type arguments of an anonymous class live on its super type (or
+     * the first interface once {@code InnerClassVisitor} has moved an interface
+     * super type). GROOVY-12319.
+     */
+    private static ClassNode diamondTargetOfAnonymousClass(final ClassNode anonType) {
+        ClassNode sc = anonType.getUnresolvedSuperClass(false);
+        if (sc != null && (sc.isInterface() || Traits.isTrait(sc))) {
+            return sc;
+        }
+        ClassNode[] ifaces = anonType.getInterfaces();
+        if (ifaces != null && ifaces.length > 0 && (ifaces[0].isInterface() || Traits.isTrait(ifaces[0]))) {
+            return ifaces[0];
+        }
+        return sc != null ? sc : anonType;
+    }
+
+    private static ConstructorNode matchingConstructor(final ClassNode type, final int argumentCount) {
+        if (type == null || type.isInterface()) return null;
+        ConstructorNode fallback = null;
+        for (ConstructorNode ctor : type.getDeclaredConstructors()) {
+            if (fallback == null) fallback = ctor;
+            if (ctor.getParameters().length == argumentCount) return ctor;
         }
+        return fallback;
     }
 
     private void adjustGenerics(final ClassNode source, final ClassNode target) {
@@ -1957,6 +1997,7 @@ out:    if ((samParameterTypes.length == 1 && isOrImplements(samParameterTypes[0
         if (leftExpressionType.isUsingGenerics()
                 && !missesGenericsTypes(rightExpressionType)
                 && !(rightExpression instanceof ClosureExpression) // GROOVY-10277
+                && !(rightExpression instanceof ConstructorCallExpression && ((ConstructorCallExpression) rightExpression).isUsingAnonymousInnerClass()) // GROOVY-12319: AIC type is the generated class, not the diamond super type
                 && !isNullConstant(rightExpression) && !UNKNOWN_PARAMETER_TYPE.equals(rightExpressionType)
                 && !GenericsUtils.buildWildcardType(leftExpressionType).isCompatibleWith(wrapTypeIfNecessary(rightExpressionType)))
             addStaticTypeError("Incompatible generic argument types. Cannot assign " + prettyPrintType(rightExpressionType) + " to: " + prettyPrintType(leftExpressionType), rightExpression);
@@ -3083,65 +3124,81 @@ out:    if ((samParameterTypes.length == 1 && isOrImplements(samParameterTypes[0
             typeCheckingContext.getEnclosingClosure().addReturnType(returnType);
     }
 
-    /** {@inheritDoc} */
     @Override
     public void visitConstructorCallExpression(final ConstructorCallExpression call) {
-        if (!extension.beforeMethodCall(call)) {
-            ClassNode receiver;
-            if (call.isThisCall()) {
-                receiver = makeThis();
-            } else if (call.isSuperCall()) {
-                receiver = makeSuper();
-            } else {
-                receiver = call.getType();
-            }
-            Expression arguments = call.getArguments();
-            ArgumentListExpression argumentList = InvocationWriter.makeArgumentList(arguments);
+        typeCheckingContext.pushEnclosingMethodCall(call);
+        try {
+            if (!extension.beforeMethodCall(call)) {
+                ClassNode receiver;
+                if (call.isThisCall()) {
+                    receiver = makeThis();
+                } else if (call.isSuperCall()) {
+                    receiver = makeSuper();
+                } else {
+                    receiver = call.getType();
+                }
+                Expression arguments = call.getArguments();
+                ArgumentListExpression argumentList = InvocationWriter.makeArgumentList(arguments);
 
-            // visit functional arguments *after* method has been chosen
-            visitMethodCallArguments(receiver, argumentList, false, null);
-            final ClassNode[] argumentTypes = getArgumentTypes(argumentList);
+                // visit functional arguments *after* method has been chosen
+                visitMethodCallArguments(receiver, argumentList, false, null);
+                final ClassNode[] argumentTypes = getArgumentTypes(argumentList);
 
-            MethodNode ctor;
-            if (looksLikeNamedArgConstructor(receiver, argumentTypes)
-                    && findMethod(receiver, "<init>", argumentTypes).isEmpty()
-                    && findMethod(receiver, "<init>", init(argumentTypes)).size() == 1) {
-                ctor = typeCheckMapConstructor(call, receiver, arguments);
-            } else {
-                ctor = findMethodOrFail(call, receiver, "<init>", argumentTypes);
-                visitMethodCallArguments(receiver, argumentList, true, ctor);
-                if (ctor != null) {
-                    Parameter[] parameters = ctor.getParameters();
-                    GenericsType[] typeParameters = ctor.getDeclaringClass().getGenericsTypes();
-                    if (typeParameters != null) { // GROOVY-10283, GROOVY-10316, GROOVY-10482, GROOVY-10624, GROOVY-10698
-                        Map<GenericsTypeName, GenericsType> context = extractGenericsConnectionsFromArguments(typeParameters, parameters, argumentList, receiver.getGenericsTypes());
-                        if (!context.isEmpty()) parameters = Arrays.stream(parameters).map(p -> new Parameter(applyGenericsContext(context, p.getType()), p.getName())).toArray(Parameter[]::new);
-                    }
-                    resolvePlaceholdersFromImplicitTypeHints(argumentTypes, argumentList, parameters);
-                    typeCheckMethodsWithGenericsOrFail(receiver, argumentTypes, ctor, call);
-                    checkForbiddenSpreadArgument(argumentList, parameters);
+                MethodNode ctor;
+                if (looksLikeNamedArgConstructor(receiver, argumentTypes)
+                        && findMethod(receiver, "<init>", argumentTypes).isEmpty()
+                        && findMethod(receiver, "<init>", init(argumentTypes)).size() == 1) {
+                    ctor = typeCheckMapConstructor(call, receiver, arguments);
                 } else {
-                    checkForbiddenSpreadArgument(argumentList);
+                    ctor = findMethodOrFail(call, receiver, "<init>", argumentTypes);
+                    visitMethodCallArguments(receiver, argumentList, true, ctor);
+                    if (ctor != null) {
+                        Parameter[] parameters = ctor.getParameters();
+                        GenericsType[] typeParameters = ctor.getDeclaringClass().getGenericsTypes();
+                        if (typeParameters != null) { // GROOVY-10283, GROOVY-10316, GROOVY-10482, GROOVY-10624, GROOVY-10698
+                            Map<GenericsTypeName, GenericsType> context = extractGenericsConnectionsFromArguments(typeParameters, parameters, argumentList, receiver.getGenericsTypes());
+                            if (!context.isEmpty()) parameters = Arrays.stream(parameters).map(p -> new Parameter(applyGenericsContext(context, p.getType()), p.getName())).toArray(Parameter[]::new);
+                        }
+                        resolvePlaceholdersFromImplicitTypeHints(argumentTypes, argumentList, parameters);
+                        typeCheckMethodsWithGenericsOrFail(receiver, argumentTypes, ctor, call);
+                        checkForbiddenSpreadArgument(argumentList, parameters);
+                    } else {
+                        checkForbiddenSpreadArgument(argumentList);
+                    }
                 }
+                if (ctor != null) storeTargetMethod(call, ctor);
             }
-            if (ctor != null) storeTargetMethod(call, ctor);
-        }
-
-        // GROOVY-9327: check for AIC in STC method with non-STC enclosing class
-        if (call.isUsingAnonymousInnerClass()) {
-            Set<MethodNode> methods = typeCheckingContext.methodsToBeVisited;
-            if (!methods.isEmpty()) { // indicates specific methods have STC
-                typeCheckingContext.methodsToBeVisited = Collections.emptySet();
 
+            // GROOVY-9327: check for AIC in STC method with non-STC enclosing class
+            if (call.isUsingAnonymousInnerClass()) {
                 ClassNode anonType = call.getType();
-                visitClass(anonType); // visit anon. inner class inline with method
-                anonType.putNodeMetaData(StaticTypeCheckingVisitor.class, Boolean.TRUE);
+                ClassNode diamondTarget = diamondTargetOfAnonymousClass(anonType);
+                if (diamondTarget.getGenericsTypes() != null && diamondTarget.getGenericsTypes().length == 0) {
+                    BinaryExpression enclosingBinaryExpression = typeCheckingContext.getEnclosingBinaryExpression();
+                    ClassNode lType = null;
+                    if (enclosingBinaryExpression != null && isAssignment(enclosingBinaryExpression.getOperation().getType())) {
+                        lType = getType(enclosingBinaryExpression.getLeftExpression());
+                    }
+                    if (lType == null) {
+                        lType = diamondTarget.redirect();
+                    }
+                    inferDiamondType(call, lType);
+                }
+                Set<MethodNode> methods = typeCheckingContext.methodsToBeVisited;
+                if (!methods.isEmpty()) { // indicates specific methods have STC
+                    typeCheckingContext.methodsToBeVisited = Collections.emptySet();
+
+                    visitClass(anonType); // visit anon. inner class inline with method
+                    anonType.putNodeMetaData(StaticTypeCheckingVisitor.class, Boolean.TRUE);
 
-                typeCheckingContext.methodsToBeVisited = methods;
+                    typeCheckingContext.methodsToBeVisited = methods;
+                }
             }
-        }
 
-        extension.afterMethodCall(call);
+            extension.afterMethodCall(call);
+        } finally {
+            typeCheckingContext.popEnclosingMethodCall();
+        }
     }
 
     private boolean looksLikeNamedArgConstructor(final ClassNode receiver, final ClassNode[] argumentTypes) {
@@ -3935,7 +3992,22 @@ out:    if ((samParameterTypes.length == 1 && isOrImplements(samParameterTypes[0
                 boolean typeParametersResolved = false;
                 // first check for explicit type arguments
                 if (isConstructor) {
-                    typeParametersResolved = hasTypeArguments;
+                    Expression emc = typeCheckingContext.getEnclosingMethodCall();
+                    if (emc instanceof ConstructorCallExpression cce) {
+                        GenericsType[] typeArguments = cce.getGenericsTypes();
+                        if (typeArguments != null) {
+                            GenericsType[] methodTypeParameters = method.getGenericsTypes();
+                            if (methodTypeParameters != null && methodTypeParameters.length == typeArguments.length) {
+                                typeParametersResolved = true;
+                                for (int i = 0; i < methodTypeParameters.length; i += 1) {
+                                    context.put(new GenericsTypeName(methodTypeParameters[i].getName()), typeArguments[i]);
+                                }
+                            }
+                        }
+                    }
+                    if (!typeParametersResolved) {
+                        typeParametersResolved = hasTypeArguments;
+                    }
                 } else {
                     Expression emc = typeCheckingContext.getEnclosingMethodCall();
                     if (emc instanceof MethodCallExpression mce) {
@@ -4172,6 +4244,10 @@ out:    if ((samParameterTypes.length == 1 && isOrImplements(samParameterTypes[0
             if (arguments == call.getArguments() || InvocationWriter.makeArgumentList(arguments).getExpressions().stream().anyMatch(arg ->
                     arg instanceof ClosureExpression && DefaultGroovyMethods.contains(InvocationWriter.makeArgumentList(call.getArguments()), arg)))
                 typeArguments = call.getGenericsTypes();
+        } else if (emc instanceof ConstructorCallExpression call) {
+            if (arguments == call.getArguments() || InvocationWriter.makeArgumentList(arguments).getExpressions().stream().anyMatch(arg ->
+                    arg instanceof ClosureExpression && DefaultGroovyMethods.contains(InvocationWriter.makeArgumentList(call.getArguments()), arg)))
+                typeArguments = call.getGenericsTypes();
         }
 
         returnType = inferReturnTypeGenerics(receiver, methodNode, arguments, typeArguments);
@@ -4566,9 +4642,9 @@ out:                if (mn.size() != 1) {
                               case "getThisObject":
                                 returnType = makeThis();
                             }
-                        } else if (isUsingGenericsOrIsArrayUsingGenerics(returnType)) {
+                        } else if (returnType.isGenericsPlaceHolder() || isUsingGenericsOrIsArrayUsingGenerics(returnType)) {
                             ClassNode irtg = inferReturnTypeGenerics(chosenReceiver.getType(), targetMethod, callArguments, call.getGenericsTypes());
-                            if (irtg != null && implementsInterfaceOrIsSubclassOf(irtg, returnType))
+                            if (irtg != null && (returnType.isGenericsPlaceHolder() || implementsInterfaceOrIsSubclassOf(irtg, returnType)))
                                 returnType = irtg;
                         }
                         // GROOVY-7106, GROOVY-7274, GROOVY-8909, GROOVY-8961, GROOVY-9734, GROOVY-9844, GROOVY-9915, et al.
@@ -6289,6 +6365,13 @@ trying: for (ClassNode[] signature : signatures) {
     protected ClassNode getType(final ASTNode node) {
         ClassNode type = node.getNodeMetaData(INFERRED_TYPE);
         if (type != null) {
+            if (node instanceof VariableExpression vexp && vexp.getOriginType() != null && vexp.getOriginType().getNodeMetaData("outer.class") != null) {
+                if (type.getNodeMetaData("outer.class") == null) {
+                    type = type.getPlainNodeReference();
+                    type.setGenericsTypes(vexp.getOriginType().getGenericsTypes());
+                    type.putNodeMetaData("outer.class", vexp.getOriginType().getNodeMetaData("outer.class"));
+                }
+            }
             return type;
         }
 
@@ -6313,7 +6396,12 @@ trying: for (ClassNode[] signature : signatures) {
                 return fieldType;
             }
             if (variable != vexp && variable instanceof VariableExpression) {
-                return getType((VariableExpression) variable);
+                type = getType((VariableExpression) variable);
+                ClassNode originType = ((VariableExpression) variable).getOriginType();
+                if (originType != null && originType.getNodeMetaData("outer.class") != null && type != null) {
+                    type.putNodeMetaData("outer.class", originType.getNodeMetaData("outer.class"));
+                }
+                return type;
             }
             if (variable instanceof Parameter parameter) {
                 if (getTemporaryTypesForExpression(vexp).isEmpty()) { // not instanceof
@@ -7048,6 +7136,17 @@ out:    for (ClassNode type : todo) {
                 }
             }
             result = extractPlaceHolders(receiver, declaring);
+            ClassNode oc = receiver.getNodeMetaData("outer.class");
+            if (oc == null && receiver.redirect() != null) {
+                oc = receiver.redirect().getNodeMetaData("outer.class");
+            }
+            if (oc == null && argument instanceof VariableExpression vexp && vexp.getOriginType() != null) {
+                oc = vexp.getOriginType().getNodeMetaData("outer.class");
+            }
+            if (oc != null) {
+                Map<GenericsTypeName, GenericsType> outerPlaceHolders = extractPlaceHolders(oc, oc.redirect());
+                result.putAll(outerPlaceHolders);
+            }
             if (!result.isEmpty()) Optional.ofNullable(method.getGenericsTypes()).ifPresent(methodGenerics ->
                 Arrays.stream(methodGenerics).map(gt -> new GenericsTypeName(gt.getName())).forEach(result::remove)); // GROOVY-10322
         }
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/TypeCheckingContext.java b/src/main/java/org/codehaus/groovy/transform/stc/TypeCheckingContext.java
index 94e461f500..0b798ca866 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/TypeCheckingContext.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/TypeCheckingContext.java
@@ -23,6 +23,7 @@ import org.codehaus.groovy.ast.MethodNode;
 import org.codehaus.groovy.ast.Parameter;
 import org.codehaus.groovy.ast.expr.BinaryExpression;
 import org.codehaus.groovy.ast.expr.ClosureExpression;
+import org.codehaus.groovy.ast.expr.ConstructorCallExpression;
 import org.codehaus.groovy.ast.expr.Expression;
 import org.codehaus.groovy.ast.expr.MethodCallExpression;
 import org.codehaus.groovy.ast.expr.StaticMethodCallExpression;
@@ -383,13 +384,13 @@ public class TypeCheckingContext {
     /**
      * Pushes a method call into the method call stack.
      *
-     * @param call the call expression to be pushed, either a {@link MethodCallExpression} or a {@link StaticMethodCallExpression}
+     * @param call the call expression to be pushed, either a {@link MethodCallExpression}, {@link StaticMethodCallExpression}, or {@link ConstructorCallExpression}
      */
     public void pushEnclosingMethodCall(final Expression call) {
-        if (call instanceof MethodCallExpression || call instanceof StaticMethodCallExpression) {
+        if (call instanceof MethodCallExpression || call instanceof StaticMethodCallExpression || call instanceof ConstructorCallExpression) {
             enclosingMethodCalls.addFirst(call);
         } else {
-            throw new IllegalArgumentException("Expression must be a method call or a static method call");
+            throw new IllegalArgumentException("Expression must be a method call, a static method call or a constructor call");
         }
     }
 
diff --git a/src/spec/doc/core-operators.adoc b/src/spec/doc/core-operators.adoc
index 207d1a5e06..944a164325 100644
--- a/src/spec/doc/core-operators.adoc
+++ b/src/spec/doc/core-operators.adoc
@@ -909,6 +909,13 @@ same name in Java 7. It is used to indicate that generic types should be inferre
 include::../test/OperatorsTest.groovy[tags=diamond_op,indent=0]
 ----
 
+As of GROOVY-12319, diamond may also be used when creating an anonymous inner class, matching Java 9 (JEP 213):
+
+[source,groovy]
+----
+include::../test/OperatorsTest.groovy[tags=diamond_op_aic,indent=0]
+----
+
 In dynamic Groovy, this is totally unused. In statically type checked Groovy, it is also optional since the Groovy
 type checker performs type inference whether this operator is present or not.
 
diff --git a/src/spec/test/OperatorsTest.groovy b/src/spec/test/OperatorsTest.groovy
index e8ed79159e..92d5e2f4d9 100644
--- a/src/spec/test/OperatorsTest.groovy
+++ b/src/spec/test/OperatorsTest.groovy
@@ -743,6 +743,21 @@ assert function(*args,5,6) == 26
         // end::diamond_op[]
     }
 
+    @Test
+    void testDiamondOperatorOnAnonymousInnerClass() {
+        assertScript '''
+        // tag::diamond_op_aic[]
+        interface Processor<T> {
+            T process(T val)
+        }
+        Processor<String> p = new Processor<>() {
+            String process(String val) { val.toUpperCase() }
+        }
+        assert p.process('ok') == 'OK'
+        // end::diamond_op_aic[]
+        '''
+    }
+
     @Test
     void testCallOperator() {
         assertScript '''
diff --git a/src/test/groovy/bugs/Groovy12319.groovy b/src/test/groovy/bugs/Groovy12319.groovy
new file mode 100644
index 0000000000..1169442965
--- /dev/null
+++ b/src/test/groovy/bugs/Groovy12319.groovy
@@ -0,0 +1,616 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package bugs
+
+import org.codehaus.groovy.control.CompilationFailedException
+import org.junit.jupiter.api.Test
+
+import static groovy.test.GroovyAssert.assertScript
+import static groovy.test.GroovyAssert.shouldFail
+
+final class Groovy12319 {
+
+    // =========================================================================
+    // 1. Diamond <> on anonymous inner classes
+    // =========================================================================
+
+    @Test
+    void testDiamondOnAnonymousInnerClass_Basic() {
+        assertScript '''
+            interface Processor<T> {
+                T process(T val)
+            }
+
+            Processor<String> p = new Processor<>() {
+                @Override
+                String process(String val) {
+                    return val.toUpperCase()
+                }
+            }
+
+            assert p.process("hello") == "HELLO"
+        '''
+    }
+
+    @Test
+    void testDiamondOnAnonymousInnerClass_ExtendingClass() {
+        assertScript '''
+            abstract class BaseHolder<T> {
+                T value
+                BaseHolder(T value) {
+                    this.value = value
+                }
+                abstract T transform()
+            }
+
+            BaseHolder<Integer> holder = new BaseHolder<>(42) {
+                @Override
+                Integer transform() {
+                    return value * 2
+                }
+            }
+
+            assert holder.transform() == 84
+        '''
+    }
+
+    @Test
+    void testDiamondOnAnonymousInnerClass_MultipleTypeParams() {
+        assertScript '''
+            interface BiTransformer<T, U, R> {
+                R transform(T t, U u)
+            }
+
+            BiTransformer<String, Integer, String> transformer = new BiTransformer<>() {
+                @Override
+                String transform(String s, Integer i) {
+                    return s + ":" + i
+                }
+            }
+
+            assert transformer.transform("score", 100) == "score:100"
+        '''
+    }
+
+    @Test
+    void testDiamondOnAnonymousInnerClass_CompileStatic() {
+        assertScript '''
+            import groovy.transform.CompileStatic
+
+            @CompileStatic
+            class Tester {
+                interface Handler<T> {
+                    T handle(T input)
+                }
+
+                static String run() {
+                    Handler<String> h = new Handler<>() {
+                        @Override
+                        String handle(String input) {
+                            return "handled " + input
+                        }
+                    }
+                    return h.handle("data")
+                }
+            }
+
+            assert Tester.run() == "handled data"
+        '''
+    }
+
+    @Test
+    void testDiamondOnAnonymousInnerClass_TypeChecked() {
+        assertScript '''
+            import groovy.transform.TypeChecked
+
+            @TypeChecked
+            class Tester {
+                static class Box<T> {
+                    T item
+                    Box(T item) { this.item = item }
+                    T get() { return item }
+                }
+
+                static Integer run() {
+                    Box<Integer> b = new Box<>(123) {
+                        @Override
+                        Integer get() {
+                            return super.get() + 1
+                        }
+                    }
+                    return b.get()
+                }
+            }
+
+            assert Tester.run() == 124
+        '''
+    }
+
+    // =========================================================================
+    // 2. Qualified parameterized inner types ("rare" types)
+    // =========================================================================
+
+    @Test
+    void testQualifiedParameterizedInnerType_VariableDeclaration() {
+        assertScript '''
+            class Outer<T> {
+                class Inner<U> {
+                    T t
+                    U u
+                    Inner(T t, U u) {
+                        this.t = t
+                        this.u = u
+                    }
+                    String display() {
+                        return "" + t + "-" + u
+                    }
+                }
+            }
+
+            Outer<String>.Inner<Integer> x = new Outer<String>().new Inner<Integer>("val", 99)
+            assert x.display() == "val-99"
+        '''
+    }
+
+    @Test
+    void testQualifiedParameterizedInnerType_FieldsAndMethods() {
+        assertScript '''
+            class Outer<T> {
+                class Inner<U> {
+                    T t
+                    U u
+                    Inner(T t, U u) { this.t = t; this.u = u }
+                }
+            }
+
+            class Service {
+                Outer<String>.Inner<Integer> field
+
+                Outer<String>.Inner<Integer> echo(Outer<String>.Inner<Integer> param) {
+                    return param
+                }
+            }
+
+            Outer<String> outer = new Outer<>()
+            Outer<String>.Inner<Integer> inner = outer.new Outer.Inner<Integer>("abc", 123)
+            Service s = new Service(field: inner)
+            assert s.echo(s.field).t == "abc"
+            assert s.echo(s.field).u == 123
+        '''
+    }
+
+    @Test
+    void testQualifiedParameterizedInnerType_NestedGenerics() {
+        assertScript '''
+            class Outer<T> {
+                class Inner<U> {
+                    T t; U u
+                    Inner(T t, U u) { this.t = t; this.u = u }
+                }
+            }
+
+            List<Outer<String>.Inner<Integer>> list = new ArrayList<>()
+            Outer<String> o = new Outer<>()
+            list.add(o.new Outer.Inner<Integer>("item", 1))
+            assert list.size() == 1
+            assert list[0].t == "item"
+            assert list[0].u == 1
+        '''
+    }
+
+    @Test
+    void testQualifiedParameterizedInnerType_CompileStatic() {
+        assertScript '''
+            import groovy.transform.CompileStatic
+
+            class Outer<T> {
+                class Inner<U> {
+                    T t
+                    U u
+                    Inner(T t, U u) {
+                        this.t = t
+                        this.u = u
+                    }
+                    T getT() { return t }
+                    U getU() { return u }
+                }
+            }
+
+            @CompileStatic
+            class Tester {
+                static String test() {
+                    Outer<String> outer = new Outer<String>()
+                    Outer<String>.Inner<Integer> inner = outer.new Outer.Inner<Integer>("hello", 42)
+                    return inner.getT() + ":" + inner.getU()
+                }
+            }
+
+            assert Tester.test() == "hello:42"
+        '''
+    }
+
+    @Test
+    void testQualifiedParameterizedInnerType_RawInner() {
+        assertScript '''
+            class Outer<T> {
+                class Inner {
+                    T t
+                    Inner(T t) { this.t = t }
+                    T get() { return t }
+                }
+            }
+
+            Outer<String>.Inner x = new Outer<String>().new Inner("test")
+            assert x.get() == "test"
+        '''
+    }
+
+    // =========================================================================
+    // 3. Explicit type arguments on constructors, this() and super()
+    // =========================================================================
+
+    @Test
+    void testConstructorTypeArguments_Basic() {
+        assertScript '''
+            class Box {
+                String value
+                <T> Box(T t) {
+                    this.value = t.toString()
+                }
+            }
+
+            Box b = new <String>Box("hello")
+            assert b.value == "hello"
+
+            Box b2 = new <Integer>Box(12345)
+            assert b2.value == "12345"
+        '''
+    }
+
+    @Test
+    void testConstructorTypeArguments_GenericClass() {
+        assertScript '''
+            class Pair<K> {
+                K key
+                String desc
+                <V> Pair(K key, V val) {
+                    this.key = key
+                    this.desc = val.toString()
+                }
+            }
+
+            Pair<String> p = new <Integer>Pair<String>("k1", 999)
+            assert p.key == "k1"
+            assert p.desc == "999"
+        '''
+
+        shouldFail CompilationFailedException, '''
+            class Pair<K> {
+                <V> Pair(K key, V val) {}
+            }
+            new <Integer>Pair<>("k2", 888)
+        '''
+    }
+
+    @Test
+    void testConstructorTypeArguments_InnerClass() {
+        assertScript '''
+            class Outer {
+                class Inner {
+                    String result
+                    <T> Inner(T t) {
+                        this.result = "inner:" + t
+                    }
+                }
+            }
+
+            Outer outer = new Outer()
+            Outer.Inner inner = outer.new <String>Outer.Inner("custom")
+            assert inner.result == "inner:custom"
+        '''
+    }
+
+    @Test
+    void testConstructorTypeArguments_ThisCall() {
+        assertScript '''
+            class Target {
+                String text
+                <T> Target(T t) {
+                    this.text = "generic:" + t
+                }
+                Target() {
+                    <String>this("defaultVal")
+                }
+            }
+
+            Target t = new Target()
+            assert t.text == "generic:defaultVal"
+        '''
+    }
+
+    @Test
+    void testConstructorTypeArguments_SuperCall() {
+        assertScript '''
+            class Base {
+                String message
+                <T> Base(T t) {
+                    this.message = "base:" + t
+                }
+            }
+
+            class Derived extends Base {
+                Derived() {
+                    <String>super("fromDerived")
+                }
+            }
+
+            Derived d = new Derived()
+            assert d.message == "base:fromDerived"
+        '''
+    }
+
+    @Test
+    void testConstructorTypeArguments_CompileStatic() {
+        assertScript '''
+            import groovy.transform.CompileStatic
+
+            class Holder {
+                String str
+                <T> Holder(T t) {
+                    this.str = String.valueOf(t)
+                }
+            }
+
+            @CompileStatic
+            class Tester {
+                static String run() {
+                    Holder h = new <String>Holder("static compiled")
+                    return h.str
+                }
+            }
+
+            assert Tester.run() == "static compiled"
+        '''
+    }
+
+    @Test
+    void testDiamondOnAnonymousInnerClass_ExtendingClass_CompileStatic() {
+        assertScript '''
+            import groovy.transform.CompileStatic
+
+            abstract class BaseHolder<T> {
+                T value
+                BaseHolder(T value) {
+                    this.value = value
+                }
+                abstract T transform()
+            }
+
+            @CompileStatic
+            class Tester {
+                static Integer run() {
+                    BaseHolder<Integer> holder = new BaseHolder<>(42) {
+                        @Override
+                        Integer transform() {
+                            return value * 2
+                        }
+                    }
+                    return holder.transform()
+                }
+            }
+
+            assert Tester.run() == 84
+        '''
+    }
+
+    @Test
+    void testDiamondOnAnonymousInnerClass_DefVariable() {
+        assertScript '''
+            interface Formatter<T> {
+                String format(T t)
+            }
+
+            def f = new Formatter<String>() {
+                @Override
+                String format(String s) {
+                    return "fmt:" + s
+                }
+            }
+            assert f.format("hello") == "fmt:hello"
+        '''
+    }
+
+    @Test
+    void testQualifiedParameterizedInnerType_Chained() {
+        assertScript '''
+            import groovy.transform.CompileStatic
+
+            class Level1<A> {
+                A a
+                Level1(A a) { this.a = a }
+
+                class Level2<B> {
+                    B b
+                    Level2(B b) { this.b = b }
+                    String summarize() {
+                        return "" + a + ":" + b
+                    }
+                }
+            }
+
+            @CompileStatic
+            class Tester {
+                static String run() {
+                    Level1<String> l1 = new Level1<String>("hello")
+                    Level1<String>.Level2<Integer> l2 = l1.new Level1.Level2<Integer>(42)
+                    return l2.summarize()
+                }
+            }
+
+            assert Tester.run() == "hello:42"
+        '''
+    }
+
+    @Test
+    void testQualifiedParameterizedInnerType_NestedInTypeArgument() {
+        assertScript '''
+            class Outer<T> {
+                class Inner<U> {
+                    T t
+                    U u
+                    Inner(T t, U u) {
+                        this.t = t
+                        this.u = u
+                    }
+                }
+            }
+
+            List<Outer<String>.Inner<Integer>> list = new ArrayList<Outer<String>.Inner<Integer>>()
+            Outer<String> o = new Outer<String>()
+            list.add(o.new Outer.Inner<Integer>("hello", 123))
+            assert list.get(0).t == "hello"
+            assert list.get(0).u == 123
+        '''
+    }
+
+    @Test
+    void testConstructorTypeArguments_MultipleTypes() {
+        assertScript '''
+            class MultiHolder {
+                String desc
+                <K, V> MultiHolder(K k, V v) {
+                    this.desc = k + " -> " + v
+                }
+            }
+
+            MultiHolder m = new <String, Integer>MultiHolder("key", 100)
+            assert m.desc == "key -> 100"
+        '''
+    }
+
+    @Test
+    void testConstructorTypeArguments_CompileStatic_ThisAndSuper() {
+        assertScript '''
+            import groovy.transform.CompileStatic
+
+            class BaseClass {
+                String value
+                <T> BaseClass(T t) {
+                    this.value = "base:" + t
+                }
+            }
+
+            @CompileStatic
+            class ChildClass extends BaseClass {
+                ChildClass(int n) {
+                    <Integer>super(n)
+                }
+                ChildClass() {
+                    <String>this("default-child")
+                }
+                <T> ChildClass(T t) {
+                    <T>super(t)
+                }
+            }
+
+            assert new ChildClass(123).value == "base:123"
+            assert new ChildClass().value == "base:default-child"
+            assert new ChildClass("explicit").value == "base:explicit"
+        '''
+    }
+
+    @Test
+    void testDiamondOnAnonymousInnerClass_MethodArgument() {
+        assertScript '''
+            interface Processor<T> {
+                T process(T val)
+            }
+
+            static String apply(Processor<String> p) {
+                p.process('ok')
+            }
+
+            assert apply(new Processor<>() {
+                @Override
+                String process(String val) { val.toUpperCase() }
+            }) == 'OK'
+        '''
+    }
+
+    @Test
+    void testQualifiedParameterizedInnerType_ThreeLevels() {
+        assertScript '''
+            class A<T> {
+                T a
+                A(T a) { this.a = a }
+                class B<U> {
+                    U b
+                    B(U b) { this.b = b }
+                    class C<V> {
+                        V c
+                        C(V c) { this.c = c }
+                        String all() { '' + a + ':' + b + ':' + c }
+                    }
+                }
+            }
+
+            A<String> a = new A<String>('x')
+            A<String>.B<Integer> b = a.new A.B<Integer>(1)
+            A<String>.B<Integer>.C<Long> c = b.new A.B.C<Long>(2L)
+            assert c.all() == 'x:1:2'
+        '''
+    }
+
+    @Test
+    void testConstructorTypeArguments_NestedThisCall() {
+        assertScript '''
+            class Box {
+                String value
+                <T> Box(T t) { this.value = String.valueOf(t) }
+                Box(int ignored) { <Double>this(1.5d) }
+            }
+
+            assert new Box(0).value == '1.5'
+        '''
+    }
+
+    @Test
+    void testInvalidDiamondUsageStillFails() {
+        shouldFail CompilationFailedException, '''
+            class MyList extends ArrayList<> {}
+        '''
+
+        shouldFail CompilationFailedException, '''
+            class Test {
+                List<> list
+            }
+        '''
+    }
+
+    @Test
+    void testConstructorTypeArgumentsAndDiamondRejected() {
+        shouldFail CompilationFailedException, '''
+            class Box {
+                <T> Box(T t) {}
+            }
+            new <String>Box<>("x")
+        '''
+    }
+}
+
diff --git a/src/test/groovy/gls/generics/GenericsJavaCompatibilityTest.groovy b/src/test/groovy/gls/generics/GenericsJavaCompatibilityTest.groovy
index e996753a80..f371c653c9 100644
--- a/src/test/groovy/gls/generics/GenericsJavaCompatibilityTest.groovy
+++ b/src/test/groovy/gls/generics/GenericsJavaCompatibilityTest.groovy
@@ -275,8 +275,8 @@ final class GenericsJavaCompatibilityTest {
                     public String getTypeName() { return typeName; }
                 }
                 public static String test() {
-                    TypeHolder h1 = new TypeHolder("text");
-                    TypeHolder h2 = new TypeHolder(42);
+                    TypeHolder h1 = new <String>TypeHolder("text");
+                    TypeHolder h2 = new <Integer>TypeHolder(42);
                     return h1.getTypeName() + "-" + h2.getTypeName();
                 }
             }
@@ -461,8 +461,7 @@ final class GenericsJavaCompatibilityTest {
                 }
             }
         '''
-        // Groovy cannot use diamond <> with anonymous inner classes; keep the rest identical.
-        compileAndCompare(className, javaSrc, toGroovy(javaSrc.replace('new Processor<>()', 'new Processor<String>()')), 'Processed: Data', false)
+        assertPositive(className, javaSrc, 'Processed: Data')
     }
 
     @Test
@@ -836,6 +835,30 @@ final class GenericsJavaCompatibilityTest {
         assertPositive(className, javaSrc, 'inner')
     }
 
+    @Test
+    void testRareTypeQualifiedInnerClass() {
+        final String className = 'gls.generics.test.RareTypeInner'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class RareTypeInner {
+                public static class Outer<T> {
+                    public class Inner<U> {
+                        private final U u;
+                        Inner(U u) { this.u = u; }
+                        public U getU() { return u; }
+                    }
+                    public Inner<Integer> make(Integer u) { return new Inner<Integer>(u); }
+                }
+                public static String test() {
+                    Outer<String> outer = new Outer<String>();
+                    Outer<String>.Inner<Integer> inner = outer.make(Integer.valueOf(7));
+                    return String.valueOf(inner.getU());
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, '7')
+    }
+
     @Test
     void testStaticNestedClassHasIndependentTypeParameters() {
         final String className = 'gls.generics.test.StaticNestedIndependent'
diff --git a/src/test/groovy/gls/generics/GenericsUsageTest.groovy b/src/test/groovy/gls/generics/GenericsUsageTest.groovy
index 5957cd625c..194b97bafa 100644
--- a/src/test/groovy/gls/generics/GenericsUsageTest.groovy
+++ b/src/test/groovy/gls/generics/GenericsUsageTest.groovy
@@ -323,10 +323,9 @@ final class GenericsUsageTest {
         // constructor call
         assertScript '''
             List<String> list = new LinkedList<>()
+            def aic = new LinkedList<>() { }
+            assert aic instanceof LinkedList
         '''
-        shouldFailCompilationWithMessage '''
-            new LinkedList<>() { }
-        ''', 'Cannot use diamond <> with anonymous inner classes'
         shouldFailCompilationWithMessages '''
             new LinkedList<Integer, String>()
         ''', '(supplied with 2 type parameters)', 'which takes 1 parameter'
diff --git a/src/test/groovy/groovy/transform/stc/GenericsSTCTest.groovy b/src/test/groovy/groovy/transform/stc/GenericsSTCTest.groovy
index e2045aa1e9..b10caf13c6 100644
--- a/src/test/groovy/groovy/transform/stc/GenericsSTCTest.groovy
+++ b/src/test/groovy/groovy/transform/stc/GenericsSTCTest.groovy
@@ -3309,12 +3309,13 @@ class GenericsSTCTest extends StaticTypeCheckingTestCase {
         '''
     }
 
+    // GROOVY-12319
     @Test
     void testInferDiamondUsingAIC() {
-        shouldFailWithMessages '''
+        assertScript '''
             Map<String,Date> map = new HashMap<>() {}
-        ''',
-            'Cannot use diamond <> with anonymous inner classes'
+            assert map instanceof Map
+        '''
     }
 
     // GROOVY-5614


(groovy) 01/02: GROOVY-12319: Add test suite for Groovy compatibility with Java generics

Posted by su...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

asf-gitbox-commits pushed a commit to branch generics-tck
in repository https://gitbox.apache.org/repos/asf/groovy.git

commit de3bf992596fd60b660598d46a7b8b9cc1a156b1
Author: Daniel Sun <su...@apache.org>
AuthorDate: Sat Aug 29 08:42:17 2026 +0000

    GROOVY-12319: Add test suite for Groovy compatibility with Java generics
---
 .../generics/GenericsJavaCompatibilityTest.groovy  | 1700 ++++++++++++++++++++
 1 file changed, 1700 insertions(+)

diff --git a/src/test/groovy/gls/generics/GenericsJavaCompatibilityTest.groovy b/src/test/groovy/gls/generics/GenericsJavaCompatibilityTest.groovy
new file mode 100644
index 0000000000..e996753a80
--- /dev/null
+++ b/src/test/groovy/gls/generics/GenericsJavaCompatibilityTest.groovy
@@ -0,0 +1,1700 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package gls.generics
+
+import groovy.transform.CompileStatic
+import org.apache.groovy.util.JavaShell
+import org.apache.groovy.util.JavaShellCompilationException
+import org.codehaus.groovy.control.CompilationFailedException
+import org.codehaus.groovy.control.CompilerConfiguration
+import org.codehaus.groovy.control.customizers.ASTTransformationCustomizer
+import org.junit.jupiter.api.Test
+
+import java.lang.reflect.GenericArrayType
+import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Method
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+import java.lang.reflect.TypeVariable
+import java.lang.reflect.WildcardType
+
+import static groovy.test.GroovyAssert.shouldFail
+
+/**
+ * Static Groovy ({@code @CompileStatic}) vs javac generics compatibility suite.
+ *
+ * Each case compiles the same source twice: javac via {@link JavaShell}, and
+ * Groovy through a class loader that always applies {@link CompileStatic}.
+ * Dynamic Groovy is out of scope. Both sides must agree on compile success or
+ * failure and, when {@code test()} can run, on its result.
+ *
+ * Bytecode instruction streams, constant pools and synthetic GroovyObject
+ * machinery are not compared. Those encodings change between JDK and Groovy
+ * releases. Compatibility of the generic type system is checked at the stable
+ * reflective Signature surface ({@link Class#getTypeParameters()},
+ * {@link Class#getGenericSuperclass()}, {@link Method#getGenericReturnType()},
+ * and so on) plus observable compile / run behaviour.
+ */
+final class GenericsJavaCompatibilityTest {
+
+    // =========================================================================
+    // Category 1: Generic Class & Interface Declarations and Type Bounds
+    // =========================================================================
+
+    @Test
+    void testGenericClassSingleTypeParameter() {
+        final String className = 'gls.generics.test.SingleTypeParam'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class SingleTypeParam {
+                public static class Box<T> {
+                    private T val;
+                    public Box(T val) { this.val = val; }
+                    public T getVal() { return val; }
+                    public void setVal(T val) { this.val = val; }
+                }
+                public static String test() {
+                    Box<String> box = new Box<>("Apache Groovy");
+                    box.setVal(box.getVal() + " Generics");
+                    return box.getVal();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'Apache Groovy Generics', true)
+    }
+
+    @Test
+    void testGenericClassMultipleTypeParameters() {
+        final String className = 'gls.generics.test.MultipleTypeParams'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class MultipleTypeParams {
+                public static class Pair<K, V> {
+                    private final K key;
+                    private final V value;
+                    public Pair(K key, V value) {
+                        this.key = key;
+                        this.value = value;
+                    }
+                    public K getKey() { return key; }
+                    public V getValue() { return value; }
+                    public String format() { return "" + key + "=" + value; }
+                }
+                public static String test() {
+                    Pair<String, Integer> pair = new Pair<>("score", 100);
+                    return pair.format();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'score=100', true)
+    }
+
+    @Test
+    void testGenericInterfaceImplementation() {
+        final String className = 'gls.generics.test.GenericInterfaceImpl'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class GenericInterfaceImpl {
+                public interface Transformer<I, O> {
+                    O transform(I input);
+                }
+                public static class StringLengthTransformer implements Transformer<String, Integer> {
+                    @Override
+                    public Integer transform(String input) {
+                        return input == null ? 0 : input.length();
+                    }
+                }
+                public static int test() {
+                    Transformer<String, Integer> t = new StringLengthTransformer();
+                    return t.transform("GenericsCompatibility");
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 21, true)
+    }
+
+    @Test
+    void testSingleUpperBound() {
+        final String className = 'gls.generics.test.SingleUpperBound'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class SingleUpperBound {
+                public static class NumberHolder<T extends Number> {
+                    private final T number;
+                    public NumberHolder(T number) { this.number = number; }
+                    public double asDouble() { return number.doubleValue(); }
+                    public long asLong() { return number.longValue(); }
+                }
+                public static double test() {
+                    NumberHolder<Integer> intHolder = new NumberHolder<>(42);
+                    NumberHolder<Double> doubleHolder = new NumberHolder<>(3.14d);
+                    return intHolder.asDouble() + doubleHolder.asDouble();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 45.14d, true)
+    }
+
+    @Test
+    void testMultipleBounds() {
+        final String className = 'gls.generics.test.MultipleBounds'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.io.Serializable;
+            public class MultipleBounds {
+                public static class MultiBoundContainer<T extends Number & Comparable<T> & Serializable> {
+                    private final T first;
+                    private final T second;
+                    public MultiBoundContainer(T first, T second) {
+                        this.first = first;
+                        this.second = second;
+                    }
+                    public int compare() {
+                        return first.compareTo(second);
+                    }
+                    public double sum() {
+                        return first.doubleValue() + second.doubleValue();
+                    }
+                }
+                public static double test() {
+                    MultiBoundContainer<Integer> container = new MultiBoundContainer<>(10, 20);
+                    int cmp = container.compare();
+                    return container.sum() + cmp; // 30 + (-1) = 29
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 29.0d, true)
+    }
+
+    @Test
+    void testRecursiveTypeBoundsFBounded() {
+        final String className = 'gls.generics.test.RecursiveBounds'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class RecursiveBounds {
+                public static <T extends Comparable<T>> T findMax(List<T> list) {
+                    if (list == null || list.isEmpty()) return null;
+                    T max = list.get(0);
+                    for (int i = 1; i < list.size(); i++) {
+                        T item = list.get(i);
+                        if (item.compareTo(max) > 0) {
+                            max = item;
+                        }
+                    }
+                    return max;
+                }
+                public static String test() {
+                    List<String> names = Arrays.asList("alpha", "zebra", "beta", "gamma");
+                    return findMax(names);
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'zebra')
+    }
+
+    // =========================================================================
+    // Category 2: Generic Methods & Constructors
+    // =========================================================================
+
+    @Test
+    void testGenericMethodInference() {
+        final String className = 'gls.generics.test.MethodInference'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class MethodInference {
+                public static <T> List<T> makePairList(T first, T second) {
+                    List<T> list = new ArrayList<>();
+                    list.add(first);
+                    list.add(second);
+                    return list;
+                }
+                public static int test() {
+                    List<Integer> numbers = makePairList(10, 20);
+                    List<String> strings = makePairList("foo", "bar");
+                    return numbers.size() + strings.size();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 4)
+    }
+
+    @Test
+    void testGenericMethodExplicitTypeArguments() {
+        final String className = 'gls.generics.test.ExplicitTypeArgs'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class ExplicitTypeArgs {
+                public static class Helper {
+                    public static <T> T identity(T val) {
+                        return val;
+                    }
+                    public <E> String stringify(E val) {
+                        return String.valueOf(val);
+                    }
+                }
+                public static String test() {
+                    String a = Helper.<String>identity("Explicit");
+                    Helper h = new Helper();
+                    String b = h.<Integer>stringify(123);
+                    return a + ":" + b;
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'Explicit:123')
+    }
+
+    @Test
+    void testGenericConstructors() {
+        final String className = 'gls.generics.test.GenericConstructors'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class GenericConstructors {
+                public static class TypeHolder {
+                    private final String typeName;
+                    public <T> TypeHolder(T val) {
+                        this.typeName = val.getClass().getSimpleName();
+                    }
+                    public String getTypeName() { return typeName; }
+                }
+                public static String test() {
+                    TypeHolder h1 = new TypeHolder("text");
+                    TypeHolder h2 = new TypeHolder(42);
+                    return h1.getTypeName() + "-" + h2.getTypeName();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'String-Integer')
+    }
+
+    @Test
+    void testGenericVarargs() {
+        final String className = 'gls.generics.test.GenericVarargs'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class GenericVarargs {
+                @SafeVarargs
+                public static <T> List<T> collect(T... items) {
+                    List<T> list = new ArrayList<>();
+                    for (T item : items) {
+                        list.add(item);
+                    }
+                    return list;
+                }
+                public static int test() {
+                    List<Integer> list = collect(1, 2, 3, 4, 5);
+                    int sum = 0;
+                    for (int n : list) {
+                        sum += n;
+                    }
+                    return sum;
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 15)
+    }
+
+    // =========================================================================
+    // Category 3: Wildcards & PECS
+    // =========================================================================
+
+    @Test
+    void testUnboundedWildcard() {
+        final String className = 'gls.generics.test.UnboundedWildcard'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class UnboundedWildcard {
+                public static int countElements(Collection<?> col) {
+                    int c = 0;
+                    for (Object o : col) {
+                        if (o != null) c++;
+                    }
+                    return c;
+                }
+                public static int test() {
+                    List<String> strList = Arrays.asList("a", "b", "c");
+                    List<Integer> intList = Arrays.asList(1, 2, null, 4);
+                    return countElements(strList) + countElements(intList);
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 6)
+    }
+
+    @Test
+    void testUpperBoundedWildcardProducer() {
+        final String className = 'gls.generics.test.UpperBoundedWildcard'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class UpperBoundedWildcard {
+                public static double sumOfList(List<? extends Number> list) {
+                    double s = 0.0;
+                    for (Number n : list) {
+                        s += n.doubleValue();
+                    }
+                    return s;
+                }
+                public static double test() {
+                    List<Integer> li = Arrays.asList(1, 2, 3);
+                    List<Double> ld = Arrays.asList(1.5d, 2.5d);
+                    return sumOfList(li) + sumOfList(ld);
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 10.0d)
+    }
+
+    @Test
+    void testLowerBoundedWildcardConsumer() {
+        final String className = 'gls.generics.test.LowerBoundedWildcard'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class LowerBoundedWildcard {
+                public static void addNumbers(List<? super Integer> list) {
+                    for (int i = 1; i <= 3; i++) {
+                        list.add(i);
+                    }
+                }
+                public static int test() {
+                    List<Integer> intList = new ArrayList<>();
+                    List<Number> numList = new ArrayList<>();
+                    List<Object> objList = new ArrayList<>();
+                    addNumbers(intList);
+                    addNumbers(numList);
+                    addNumbers(objList);
+                    return intList.size() + numList.size() + objList.size();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 9)
+    }
+
+    @Test
+    void testWildcardCaptureHelper() {
+        final String className = 'gls.generics.test.WildcardCapture'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class WildcardCapture {
+                private static <T> void swapHelper(List<T> list, int i, int j) {
+                    T temp = list.get(i);
+                    list.set(i, list.get(j));
+                    list.set(j, temp);
+                }
+                public static void swap(List<?> list, int i, int j) {
+                    swapHelper(list, i, j);
+                }
+                public static String test() {
+                    List<String> list = new ArrayList<>(Arrays.asList("first", "second"));
+                    swap(list, 0, 1);
+                    return list.get(0) + "-" + list.get(1);
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'second-first')
+    }
+
+    // =========================================================================
+    // Category 4: Diamond Operator <> & Type Inference
+    // =========================================================================
+
+    @Test
+    void testDiamondOperatorWithNestedGenerics() {
+        final String className = 'gls.generics.test.NestedDiamond'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class NestedDiamond {
+                public static int test() {
+                    Map<String, List<Map<Integer, String>>> complexMap = new HashMap<>();
+                    List<Map<Integer, String>> innerList = new ArrayList<>();
+                    Map<Integer, String> innerMap = new HashMap<>();
+                    innerMap.put(1, "one");
+                    innerList.add(innerMap);
+                    complexMap.put("root", innerList);
+                    return complexMap.get("root").get(0).get(1).length();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 3)
+    }
+
+    @Test
+    void testDiamondAnonymousInnerClass() {
+        final String className = 'gls.generics.test.DiamondAnonymous'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class DiamondAnonymous {
+                public interface Processor<T> {
+                    T process(T val);
+                }
+                public static String test() {
+                    Processor<String> p = new Processor<>() {
+                        @Override
+                        public String process(String val) {
+                            return "Processed: " + val;
+                        }
+                    };
+                    return p.process("Data");
+                }
+            }
+        '''
+        // Groovy cannot use diamond <> with anonymous inner classes; keep the rest identical.
+        compileAndCompare(className, javaSrc, toGroovy(javaSrc.replace('new Processor<>()', 'new Processor<String>()')), 'Processed: Data', false)
+    }
+
+    @Test
+    void testTargetTypeInference() {
+        final String className = 'gls.generics.test.TargetTypeInference'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class TargetTypeInference {
+                public static <T> List<T> empty() {
+                    return Collections.emptyList();
+                }
+                public static int test() {
+                    List<String> sList = empty();
+                    List<Integer> iList = empty();
+                    return sList.size() + iList.size();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 0)
+    }
+
+    // =========================================================================
+    // Category 5: Covariance, Bridge Methods & Overriding
+    // =========================================================================
+
+    @Test
+    void testCovariantReturnAndBridgeMethod() {
+        final String className = 'gls.generics.test.BridgeAndCovariance'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class BridgeAndCovariance {
+                public interface Supplier<T> {
+                    T get();
+                }
+                public static class StringSupplier implements Supplier<String> {
+                    @Override
+                    public String get() {
+                        return "Hello from Bridge";
+                    }
+                }
+                public static String test() {
+                    StringSupplier specific = new StringSupplier();
+                    Supplier<String> genericRef = specific;
+                    @SuppressWarnings("rawtypes")
+                    Supplier rawRef = specific;
+                    return genericRef.get() + "|" + rawRef.get();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'Hello from Bridge|Hello from Bridge', true)
+    }
+
+    // =========================================================================
+    // Category 6: Raw Types & Interoperability
+    // =========================================================================
+
+    @Test
+    void testRawTypeInterop() {
+        final String className = 'gls.generics.test.RawTypeInterop'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class RawTypeInterop {
+                @SuppressWarnings({"rawtypes", "unchecked"})
+                public static int test() {
+                    List<String> typedList = new ArrayList<>();
+                    typedList.add("a");
+                    typedList.add("b");
+                    List rawList = typedList;
+                    rawList.add("c");
+                    return rawList.size();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 3)
+    }
+
+    // =========================================================================
+    // Category 7: Generic Exceptions & Parametric Throwables
+    // =========================================================================
+
+    @Test
+    void testGenericThrowsClause() {
+        final String className = 'gls.generics.test.GenericThrows'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.io.IOException;
+            public class GenericThrows {
+                public interface Action<E extends Exception> {
+                    void execute() throws E;
+                }
+                public static <E extends Exception> void runAction(Action<E> action) throws E {
+                    action.execute();
+                }
+                public static String test() {
+                    final StringBuilder sb = new StringBuilder();
+                    try {
+                        runAction(new Action<IOException>() {
+                            @Override
+                            public void execute() throws IOException {
+                                sb.append("executed");
+                                throw new IOException("io-fail");
+                            }
+                        });
+                    } catch (IOException e) {
+                        sb.append(":caught-").append(e.getMessage());
+                    }
+                    return sb.toString();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'executed:caught-io-fail')
+    }
+
+    // =========================================================================
+    // Category 8: Strict Negative Verification (Compile-time & Runtime)
+    // =========================================================================
+
+    @Test
+    void testNegativeGenericSubclassOfThrowable() {
+        // JLS 8.1.2: a generic class may not extend Throwable. javac rejects this;
+        // static Groovy currently accepts the equivalent source, so only the Java side is asserted.
+        final String className = 'gls.generics.test.GenEx'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class GenEx<T> extends Exception {
+                private T info;
+            }
+        '''
+        JavaShell js = new JavaShell()
+        Throwable javaEx = shouldFail(JavaShellCompilationException) {
+            js.compile(className, javaSrc)
+        }
+        assert javaEx.message.contains("generic class may not extend 'java.lang.Throwable'") ||
+            javaEx.message.contains("a generic class may not extend java.lang.Throwable")
+    }
+
+    @Test
+    void testNegativeTypeArityMismatch() {
+        final String className = 'gls.generics.test.ArityMismatch'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.List;
+            public class ArityMismatch {
+                public List<String, Integer> list;
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "wrong number of type arguments", "supplied with 2 type parameters")
+    }
+
+    @Test
+    void testNegativeMethodParamArityMismatch() {
+        final String className = 'gls.generics.test.MethodArityMismatch'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.Map;
+            public class MethodArityMismatch {
+                public void process(Map<String> map) {}
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "wrong number of type arguments", "supplied with 1 type parameter")
+    }
+
+    @Test
+    void testNegativeGenericInvarianceAssignment() {
+        final String className = 'gls.generics.test.InvarianceFail'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class InvarianceFail {
+                public static void test() {
+                    List<Number> nums = new ArrayList<Integer>();
+                }
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "incompatible types", "Cannot assign")
+    }
+
+    @Test
+    void testNegativeMultipleBoundsMismatch() {
+        final String className = 'gls.generics.test.MultiBoundFail'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class MultiBoundFail {
+                public static class Holder<T extends Number & Comparable<T>> {}
+                public static void test() {
+                    Holder<Object> h = new Holder<Object>();
+                }
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "not within bounds", "not a valid substitute for the bounded parameter")
+    }
+
+    @Test
+    void testNegativeWildcardInExtendsClause() {
+        final String className = 'gls.generics.test.WildcardSuper'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            public class WildcardSuper extends ArrayList<? extends Number> {
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "unexpected type", "A supertype may not specify a wildcard type")
+    }
+
+    @Test
+    void testNegativeParametricTypeForNonGenericClass() {
+        final String className = 'gls.generics.test.NonGenericParameterized'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.Date;
+            public class NonGenericParameterized {
+                public static void test() {
+                    Object o = new Date<String>();
+                }
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "does not take parameters", "which takes no parameters")
+    }
+
+    @Test
+    void testNegativeDuplicateGenericInterfaceInheritance() {
+        final String className = 'gls.generics.test.InterfaceConflict'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class InterfaceConflict implements Comparable<String>, Comparable<Integer> {
+                public int compareTo(String o) { return 0; }
+                public int compareTo(Integer o) { return 0; }
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "different arguments", "Duplicate interfaces in implements list")
+    }
+
+    @Test
+    void testNegativeMethodArgumentTypeMismatch() {
+        final String className = 'gls.generics.test.CallMismatch'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.*;
+            public class CallMismatch {
+                public static void test() {
+                    List<String> list = new ArrayList<>();
+                    list.add(123);
+                }
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "incompatible types", "Cannot call")
+    }
+
+    @Test
+    void testNegativeHeapPollutionClassCastException() {
+        final String className = 'gls.generics.test.HeapPollution'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class HeapPollution {
+                public interface Sink<T> {
+                    void accept(T item);
+                }
+                public static class IntegerSink implements Sink<Integer> {
+                    private Integer value;
+                    @Override
+                    public void accept(Integer item) {
+                        this.value = item;
+                    }
+                }
+                @SuppressWarnings({"rawtypes", "unchecked"})
+                public static void invokeRaw(Sink sink, Object item) {
+                    sink.accept(item);
+                }
+                public static void test() {
+                    invokeRaw(new IntegerSink(), "not an integer");
+                }
+            }
+        '''
+        assertNegativeRuntime(className, javaSrc, ClassCastException.class)
+    }
+
+    // =========================================================================
+    // Category 9: Inheritance, enclosing types, and bound forwarding
+    // =========================================================================
+
+    @Test
+    void testGenericClassExtendsParameterizedType() {
+        final String className = 'gls.generics.test.ExtendsParameterized'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class ExtendsParameterized {
+                public static class Holder<T> {
+                    private final T value;
+                    public Holder(T value) { this.value = value; }
+                    public T getValue() { return value; }
+                }
+                public static class Named extends Holder<String> {
+                    public Named(String value) { super(value); }
+                }
+                public static String test() {
+                    Holder<String> h = new Named("ok");
+                    return h.getValue();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'ok', true)
+    }
+
+    @Test
+    void testTypeParameterForwardedToSuperclass() {
+        final String className = 'gls.generics.test.ForwardTypeParam'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class ForwardTypeParam {
+                public static class Holder<T> {
+                    private T value;
+                    public void set(T value) { this.value = value; }
+                    public T get() { return value; }
+                }
+                public static class Box<T> extends Holder<T> {
+                }
+                public static String test() {
+                    Box<String> box = new Box<>();
+                    box.set("fwd");
+                    return box.get();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'fwd', true)
+    }
+
+    @Test
+    void testGenericInterfaceExtendsGenericInterface() {
+        final String className = 'gls.generics.test.GenericIfaceExtends'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class GenericIfaceExtends {
+                public interface Src<T> {
+                    T get();
+                }
+                public interface SrcNum extends Src<Number> {
+                }
+                public static class Impl implements SrcNum {
+                    @Override
+                    public Number get() { return Integer.valueOf(7); }
+                }
+                public static int test() {
+                    SrcNum s = new Impl();
+                    return s.get().intValue();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 7, true)
+    }
+
+    @Test
+    void testNonStaticInnerClassUsesEnclosingTypeParameter() {
+        final String className = 'gls.generics.test.EnclosingTypeParam'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class EnclosingTypeParam<T> {
+                public class Inner {
+                    private final T value;
+                    Inner(T value) { this.value = value; }
+                    public T getValue() { return value; }
+                }
+                public Inner make(T value) { return new Inner(value); }
+                public static String test() {
+                    EnclosingTypeParam<String> outer = new EnclosingTypeParam<String>();
+                    return outer.make("inner").getValue();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'inner')
+    }
+
+    @Test
+    void testStaticNestedClassHasIndependentTypeParameters() {
+        final String className = 'gls.generics.test.StaticNestedIndependent'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class StaticNestedIndependent {
+                public static class Outer<T> {
+                    public static class Cell<U> {
+                        private final U value;
+                        public Cell(U value) { this.value = value; }
+                        public U getValue() { return value; }
+                    }
+                }
+                public static String test() {
+                    Outer.Cell<Integer> cell = new Outer.Cell<>(42);
+                    return String.valueOf(cell.getValue());
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, '42', true)
+    }
+
+    @Test
+    void testTypeParameterUsedAsBoundOfAnother() {
+        final String className = 'gls.generics.test.TypeParamAsBound'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class TypeParamAsBound {
+                public static <T, U extends T> U pick(U value) {
+                    return value;
+                }
+                public static String test() {
+                    CharSequence cs = pick("bound");
+                    return cs.toString();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'bound')
+    }
+
+    @Test
+    void testForwardReferencedTypeParameterBounds() {
+        final String className = 'gls.generics.test.ForwardRefBounds'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            import java.util.List;
+            public class ForwardRefBounds {
+                public static class Foo<T extends List<X>, X extends Number> {
+                    private final T list;
+                    public Foo(T list) { this.list = list; }
+                    public double first() { return list.get(0).doubleValue(); }
+                }
+                public static double test() {
+                    ArrayList<Integer> nums = new ArrayList<Integer>();
+                    nums.add(Integer.valueOf(9));
+                    Foo<ArrayList<Integer>, Integer> foo = new Foo<>(nums);
+                    return foo.first();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 9.0d, true)
+    }
+
+    @Test
+    void testFBoundedSelfType() {
+        final String className = 'gls.generics.test.FBoundedSelfType'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class FBoundedSelfType {
+                public abstract static class Entity<T extends Entity<T>> {
+                    public abstract T self();
+                    public T fluent() { return self(); }
+                }
+                public static class User extends Entity<User> {
+                    @Override
+                    public User self() { return this; }
+                    public String name() { return "user"; }
+                }
+                public static String test() {
+                    return new User().fluent().name();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'user', true)
+    }
+
+    @Test
+    void testIntersectionBoundUsedAsBothTypes() {
+        final String className = 'gls.generics.test.IntersectionDispatch'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class IntersectionDispatch {
+                public static <T extends Number & Comparable<T>> String describe(T value) {
+                    return value.getClass().getSimpleName() + ":" + value.intValue() + ":" + value.compareTo(value);
+                }
+                public static String test() {
+                    return describe(Integer.valueOf(5));
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'Integer:5:0')
+    }
+
+    @Test
+    void testIndependentBoundedTypeParameters() {
+        final String className = 'gls.generics.test.IndependentBoundedParams'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class IndependentBoundedParams {
+                public static class Mix<A extends CharSequence, B extends Number> {
+                    public String mix(A a, B b) {
+                        return a.toString() + b.intValue();
+                    }
+                }
+                public static String test() {
+                    Mix<String, Integer> mix = new Mix<>();
+                    return mix.mix("n", Integer.valueOf(3));
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'n3', true)
+    }
+
+    // =========================================================================
+    // Category 10: Generic methods on generic types, arrays as type arguments
+    // =========================================================================
+
+    @Test
+    void testGenericMethodOnGenericClass() {
+        final String className = 'gls.generics.test.GenericMethodOnGenericClass'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.function.Function;
+            public class GenericMethodOnGenericClass {
+                public static class Box<T> {
+                    private final T value;
+                    public Box(T value) { this.value = value; }
+                    public <U> U map(Function<T, U> mapper) {
+                        return mapper.apply(value);
+                    }
+                }
+                public static int test() {
+                    Box<String> box = new Box<>("abcd");
+                    return box.map(s -> s.length());
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 4)
+    }
+
+    @Test
+    void testArrayAsTypeArgument() {
+        final String className = 'gls.generics.test.ArrayAsTypeArg'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            import java.util.List;
+            public class ArrayAsTypeArg {
+                public static int test() {
+                    List<String[]> list = new ArrayList<String[]>();
+                    list.add(new String[] {"a", "bb"});
+                    return list.get(0)[1].length();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 2)
+    }
+
+    @Test
+    void testChainedGenericMethodInference() {
+        final String className = 'gls.generics.test.ChainedInference'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class ChainedInference {
+                public static <T> T id(T value) {
+                    return value;
+                }
+                public static String test() {
+                    return id(id("ok"));
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'ok')
+    }
+
+    @Test
+    void testOverrideGenericMethodWithMatchingBounds() {
+        final String className = 'gls.generics.test.OverrideMatchingBounds'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class OverrideMatchingBounds {
+                public interface Rec<T extends Rec<T>> {
+                }
+                public static class Base {
+                    public <T extends Rec<T>> String tag() { return "base"; }
+                }
+                public static class Sub extends Base {
+                    @Override
+                    public <U extends Rec<U>> String tag() { return "sub"; }
+                }
+                public static String test() {
+                    Base b = new Sub();
+                    return b.tag();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'sub')
+    }
+
+    // =========================================================================
+    // Category 11: PECS, nested wildcards, function variance
+    // =========================================================================
+
+    @Test
+    void testPecsCollectionsCopy() {
+        final String className = 'gls.generics.test.PecsCopy'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            import java.util.Arrays;
+            import java.util.Collections;
+            import java.util.List;
+            public class PecsCopy {
+                public static String test() {
+                    List<Integer> src = Arrays.asList(1, 2, 3);
+                    List<Number> dst = new ArrayList<Number>();
+                    dst.add(null);
+                    dst.add(null);
+                    dst.add(null);
+                    Collections.copy(dst, src);
+                    return dst.get(0).intValue() + "," + dst.get(2).intValue();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, '1,3')
+    }
+
+    @Test
+    void testNestedWildcards() {
+        final String className = 'gls.generics.test.NestedWildcards'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            import java.util.Arrays;
+            import java.util.List;
+            public class NestedWildcards {
+                public static int sizeOf(List<? extends List<? extends Number>> lists) {
+                    int n = 0;
+                    for (List<? extends Number> list : lists) {
+                        n += list.size();
+                    }
+                    return n;
+                }
+                public static int test() {
+                    List<List<Integer>> data = new ArrayList<List<Integer>>();
+                    data.add(Arrays.asList(1, 2));
+                    data.add(Arrays.asList(3));
+                    return sizeOf(data);
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 3)
+    }
+
+    @Test
+    void testComparatorSuperBoundSort() {
+        final String className = 'gls.generics.test.ComparatorSuperBound'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            import java.util.Comparator;
+            import java.util.List;
+            public class ComparatorSuperBound {
+                public static String test() {
+                    List<Integer> list = new ArrayList<Integer>();
+                    list.add(Integer.valueOf(3));
+                    list.add(Integer.valueOf(1));
+                    list.add(Integer.valueOf(2));
+                    Comparator<Number> byInt = (a, b) -> Integer.compare(a.intValue(), b.intValue());
+                    list.sort(byInt);
+                    return list.get(0) + "," + list.get(1) + "," + list.get(2);
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, '1,2,3')
+    }
+
+    @Test
+    void testFunctionWildcardVariance() {
+        final String className = 'gls.generics.test.FunctionVariance'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.function.Function;
+            public class FunctionVariance {
+                public static <T, R> R apply(Function<? super T, ? extends R> f, T value) {
+                    return f.apply(value);
+                }
+                public static int test() {
+                    Function<Object, Integer> f = o -> String.valueOf(o).length();
+                    return apply(f, "xyz");
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 3)
+    }
+
+    @Test
+    void testLowerBoundedWildcardGetReturnsObject() {
+        final String className = 'gls.generics.test.LowerBoundGet'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            import java.util.List;
+            public class LowerBoundGet {
+                public static String test() {
+                    List<? super Integer> list = new ArrayList<Number>();
+                    list.add(Integer.valueOf(8));
+                    Object value = list.get(0);
+                    return String.valueOf(value);
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, '8')
+    }
+
+    @Test
+    void testWildcardAllowsAddingNull() {
+        final String className = 'gls.generics.test.WildcardAddNull'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            import java.util.List;
+            public class WildcardAddNull {
+                public static int test() {
+                    List<?> list = new ArrayList<String>();
+                    list.add(null);
+                    return list.size();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 1)
+    }
+
+    // =========================================================================
+    // Category 12: Diamond target typing, unchecked conversion, raw assignment
+    // =========================================================================
+
+    @Test
+    void testDiamondInferredFromMethodArgument() {
+        final String className = 'gls.generics.test.DiamondMethodArg'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            import java.util.List;
+            public class DiamondMethodArg {
+                public static int len(List<String> list) {
+                    return list.size();
+                }
+                public static int test() {
+                    return len(new ArrayList<>());
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 0)
+    }
+
+    @Test
+    void testUncheckedCastToParameterizedType() {
+        final String className = 'gls.generics.test.UncheckedCast'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.Arrays;
+            import java.util.List;
+            public class UncheckedCast {
+                @SuppressWarnings("unchecked")
+                public static String test() {
+                    List<?> wild = Arrays.asList("cast");
+                    List<String> typed = (List<String>) wild;
+                    return typed.get(0);
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'cast')
+    }
+
+    @Test
+    void testRawTypeAssignedToParameterizedType() {
+        final String className = 'gls.generics.test.RawToParameterized'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            import java.util.List;
+            public class RawToParameterized {
+                @SuppressWarnings({"rawtypes", "unchecked"})
+                public static int test() {
+                    List raw = new ArrayList();
+                    raw.add("x");
+                    List<String> typed = raw;
+                    return typed.get(0).length();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 1)
+    }
+
+    @Test
+    void testMapEntryParameterizedInnerInterface() {
+        final String className = 'gls.generics.test.MapEntryInner'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.HashMap;
+            import java.util.Iterator;
+            import java.util.Map;
+            public class MapEntryInner {
+                public static String test() {
+                    Map<String, Integer> map = new HashMap<>();
+                    map.put("k", Integer.valueOf(3));
+                    Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
+                    Map.Entry<String, Integer> e = it.next();
+                    return e.getKey() + e.getValue();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'k3')
+    }
+
+    // =========================================================================
+    // Category 13: Covariant override, conditional lub, records, instanceof
+    // =========================================================================
+
+    @Test
+    void testCovariantOverrideInGenericClassHierarchy() {
+        final String className = 'gls.generics.test.CovariantClassOverride'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class CovariantClassOverride {
+                public static class Parent<T> {
+                    public T id(T value) { return value; }
+                }
+                public static class Child extends Parent<String> {
+                    @Override
+                    public String id(String value) { return value + "!"; }
+                }
+                public static String test() {
+                    Parent<String> p = new Child();
+                    return p.id("ok");
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'ok!', true)
+    }
+
+    @Test
+    void testConditionalExpressionLubsClassLiterals() {
+        final String className = 'gls.generics.test.ConditionalLub'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class ConditionalLub {
+                public static String test() {
+                    boolean cond = "x".length() == 1;
+                    Class<?> cls = cond ? Integer.class : Double.class;
+                    CharSequence cs = cond ? "hello" : new StringBuilder("hello");
+                    return cls.getSimpleName() + cs.toString();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'Integerhello')
+    }
+
+    @Test
+    void testGenericRecord() {
+        final String className = 'gls.generics.test.GenericRecordPair'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class GenericRecordPair {
+                public static record Pair<K, V>(K key, V value) {
+                }
+                public static String test() {
+                    Pair<String, Integer> pair = new Pair<>("a", Integer.valueOf(1));
+                    return pair.key() + pair.value();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'a1', true)
+    }
+
+    @Test
+    void testReifiableInstanceofUnboundedWildcard() {
+        final String className = 'gls.generics.test.ReifiableInstanceof'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.ArrayList;
+            import java.util.List;
+            public class ReifiableInstanceof {
+                public static boolean test() {
+                    Object list = new ArrayList<String>();
+                    Object cls = ReifiableInstanceof.class.getClass();
+                    return (list instanceof List<?>) && (cls instanceof Class<?>);
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, true)
+    }
+
+    @Test
+    void testDeclaredGenericSignaturesMatch() {
+        final String className = 'gls.generics.test.SignatureCatalog'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.List;
+            public class SignatureCatalog {
+                public static class Box<T> {
+                    public T value;
+                    public Box(T value) { this.value = value; }
+                    public T getValue() { return value; }
+                }
+                public static class Pair<K extends Number, V extends CharSequence> {
+                    public final K k;
+                    public final V v;
+                    public Pair(K k, V v) { this.k = k; this.v = v; }
+                }
+                public static class Bounded<T extends Number & Comparable<T>> {
+                    public int compare(T a, T b) { return a.compareTo(b); }
+                }
+                public static class Sub extends Box<String> {
+                    public Sub(String value) { super(value); }
+                }
+                public List<? extends Number> extendsBound;
+                public List<? super Integer> superBound;
+                public List<?> unbounded;
+                public static <E> E identity(E value) { return value; }
+                public static String test() {
+                    Box<String> box = new Box<>("x");
+                    Pair<Integer, String> pair = new Pair<>(Integer.valueOf(1), "a");
+                    Bounded<Integer> bounded = new Bounded<>();
+                    Sub sub = new Sub("s");
+                    return identity(box.getValue()) + pair.v + bounded.compare(Integer.valueOf(2), Integer.valueOf(3)) + sub.getValue();
+                }
+            }
+        '''
+        assertPositive(className, javaSrc, 'xa-1s', true)
+    }
+
+    // =========================================================================
+    // Category 14: Additional negative cases (JLS restrictions both sides share)
+    // =========================================================================
+
+    @Test
+    void testNegativeNonReifiableInstanceof() {
+        final String className = 'gls.generics.test.NonReifiableInstanceof'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.List;
+            public class NonReifiableInstanceof {
+                public static boolean test(Object o) {
+                    return o instanceof List<String>;
+                }
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "cannot be safely cast", "Cannot perform instanceof")
+    }
+
+    @Test
+    void testNegativeInstanceofParameterizedClassLiteral() {
+        final String className = 'gls.generics.test.InstanceofClassParam'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class InstanceofClassParam {
+                public static boolean test() {
+                    return InstanceofClassParam.class.getClass() instanceof Class<InstanceofClassParam>;
+                }
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "cannot be converted", "Cannot perform instanceof")
+    }
+
+    @Test
+    void testNegativeTypeParameterReferencedFromStaticNestedClass() {
+        final String className = 'gls.generics.test.StaticNestedOuterTp'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class StaticNestedOuterTp<T> {
+                static class Inner {
+                    T field;
+                }
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "non-static type variable", "unable to resolve class T")
+    }
+
+    @Test
+    void testNegativeTypeParameterStaticField() {
+        final String className = 'gls.generics.test.StaticTypeParamField'
+        final String javaSrc = '''
+            package gls.generics.test;
+            public class StaticTypeParamField<T> {
+                static T field;
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "non-static type variable", "unable to resolve class T")
+    }
+
+    @Test
+    void testNegativeWildcardWriteThroughExtends() {
+        final String className = 'gls.generics.test.WildcardWriteExtends'
+        final String javaSrc = '''
+            package gls.generics.test;
+            import java.util.List;
+            public class WildcardWriteExtends {
+                public static void test(List<? extends Number> list) {
+                    list.add(Integer.valueOf(1));
+                }
+            }
+        '''
+        assertNegativeCompile(className, javaSrc, "incompatible types", "Cannot call")
+    }
+
+    // =========================================================================
+    // Test Harness Helper Methods
+    // =========================================================================
+
+    /**
+     * Static Groovy view of {@code javaSrc}: Java annotation array initializers become
+     * Groovy lists. Semicolons and the rest of the Java syntax are kept. CompileStatic
+     * is applied by {@link #newStaticGroovyClassLoader()}, not by rewriting the source.
+     */
+    private static String toGroovy(String javaSrc) {
+        javaSrc.replaceAll(/@SuppressWarnings\(\{([^}]*)\}\)/, '@SuppressWarnings([$1])')
+    }
+
+    /**
+     * Groovy class loader that always compiles with {@link CompileStatic}.
+     * Dynamic Groovy is not part of this suite.
+     */
+    private static GroovyClassLoader newStaticGroovyClassLoader() {
+        CompilerConfiguration config = new CompilerConfiguration()
+        config.addCompilationCustomizers(new ASTTransformationCustomizer(CompileStatic))
+        new GroovyClassLoader(GenericsJavaCompatibilityTest.classLoader, config)
+    }
+
+    /**
+     * Compiles {@code javaSrc} with javac and the {@link #toGroovy} view with static
+     * Groovy, then asserts matching {@code test()} results. When {@code compareSignatures}
+     * is true, user-declared generic signatures are compared through reflection.
+     */
+    private void assertPositive(String className, String javaSrc, Object expectedResult, boolean compareSignatures = false) {
+        compileAndCompare(className, javaSrc, toGroovy(javaSrc), expectedResult, compareSignatures)
+    }
+
+    private void compileAndCompare(String className, String javaSrc, String groovySrc, Object expectedResult, boolean compareSignatures) {
+        JavaShell js = new JavaShell()
+        Class<?> javaClass = js.compile(className, javaSrc)
+        Object javaResult = javaClass.getMethod('test').invoke(null)
+
+        Class<?> groovyClass = newStaticGroovyClassLoader().parseClass(groovySrc)
+        Object groovyResult = groovyClass.getMethod('test').invoke(null)
+
+        assert javaResult == groovyResult: "Execution result mismatch between Java ($javaResult) and Groovy ($groovyResult)"
+        if (expectedResult != null) {
+            assert javaResult == expectedResult: "Java result ($javaResult) does not match expected ($expectedResult)"
+            assert groovyResult == expectedResult: "Groovy result ($groovyResult) does not match expected ($expectedResult)"
+        }
+        if (compareSignatures) {
+            assertUserGenericDeclarations(javaClass, groovyClass)
+        }
+    }
+
+    /**
+     * Compares user-visible generic declarations of {@code javaClass} and {@code groovyClass}.
+     * GroovyObject, synthetic members and extra Groovy nested types are ignored so the check
+     * stays stable across compiler revisions.
+     */
+    private static void assertUserGenericDeclarations(Class<?> javaClass, Class<?> groovyClass) {
+        assertTypeParametersEqual(javaClass, groovyClass)
+        assertGenericSuperclassEqual(javaClass, groovyClass)
+        assertUserGenericInterfacesEqual(javaClass, groovyClass)
+        assertMatchingMethodsGeneric(javaClass, groovyClass)
+        assertMatchingFieldsGeneric(javaClass, groovyClass)
+
+        for (Class<?> javaNested : javaClass.getDeclaredClasses()) {
+            String simple = javaNested.getSimpleName()
+            if (simple == null || simple.isEmpty() || simple.matches(/\d+/)) {
+                continue
+            }
+            Class<?> groovyNested = groovyClass.getDeclaredClasses().find { it.simpleName == simple }
+            assert groovyNested != null: "Groovy is missing nested type ${javaClass.name}\$${simple}"
+            assertUserGenericDeclarations(javaNested, groovyNested)
+        }
+    }
+
+    private static void assertTypeParametersEqual(Class<?> javaClass, Class<?> groovyClass) {
+        TypeVariable<?>[] javaParams = javaClass.getTypeParameters()
+        TypeVariable<?>[] groovyParams = groovyClass.getTypeParameters()
+        assert javaParams.length == groovyParams.length:
+            "${javaClass.simpleName} type-parameter arity Java=${javaParams.length} Groovy=${groovyParams.length}"
+        for (int i = 0; i < javaParams.length; i++) {
+            assert javaParams[i].name == groovyParams[i].name:
+                "${javaClass.simpleName} type-parameter name Java=${javaParams[i].name} Groovy=${groovyParams[i].name}"
+            List<String> javaBounds = javaParams[i].bounds.collect { typeDesc(it) }
+            List<String> groovyBounds = groovyParams[i].bounds.collect { typeDesc(it) }
+            assert javaBounds == groovyBounds:
+                "${javaClass.simpleName}<${javaParams[i].name}> bounds Java=${javaBounds} Groovy=${groovyBounds}"
+        }
+    }
+
+    private static void assertGenericSuperclassEqual(Class<?> javaClass, Class<?> groovyClass) {
+        String javaSuper = typeDesc(javaClass.getGenericSuperclass())
+        String groovySuper = typeDesc(groovyClass.getGenericSuperclass())
+        assert javaSuper == groovySuper:
+            "${javaClass.simpleName} generic superclass Java=${javaSuper} Groovy=${groovySuper}"
+    }
+
+    private static void assertUserGenericInterfacesEqual(Class<?> javaClass, Class<?> groovyClass) {
+        List<String> javaIfaces = userGenericInterfaces(javaClass)
+        List<String> groovyIfaces = userGenericInterfaces(groovyClass)
+        assert javaIfaces == groovyIfaces:
+            "${javaClass.simpleName} generic interfaces Java=${javaIfaces} Groovy=${groovyIfaces}"
+    }
+
+    private static List<String> userGenericInterfaces(Class<?> type) {
+        type.getGenericInterfaces().findAll { iface ->
+            String raw = rawName(iface)
+            raw != 'groovy.lang.GroovyObject' && raw != 'groovy.lang.GroovyObjectSupport'
+        }.collect { typeDesc(it) }
+    }
+
+    private static void assertMatchingMethodsGeneric(Class<?> javaClass, Class<?> groovyClass) {
+        javaClass.getDeclaredMethods().findAll { m ->
+            !m.synthetic && !m.bridge && m.name != '<clinit>' && !m.name.contains('$')
+        }.each { javaMethod ->
+            def groovyMethod = groovyClass.getDeclaredMethods().find { gm ->
+                !gm.bridge && gm.name == javaMethod.name && Arrays.equals(gm.parameterTypes, javaMethod.parameterTypes)
+            }
+            if (groovyMethod == null) {
+                return
+            }
+            String javaSig = genericMethodDesc(javaMethod)
+            String groovySig = genericMethodDesc(groovyMethod)
+            assert javaSig == groovySig:
+                "${javaClass.simpleName}.${javaMethod.name} generic signature Java=${javaSig} Groovy=${groovySig}"
+        }
+    }
+
+    private static void assertMatchingFieldsGeneric(Class<?> javaClass, Class<?> groovyClass) {
+        javaClass.getDeclaredFields().findAll { f ->
+            !f.synthetic && !f.name.contains('$') && f.name != 'metaClass'
+        }.each { javaField ->
+            def groovyField = groovyClass.getDeclaredFields().find { it.name == javaField.name }
+            if (groovyField == null) {
+                return
+            }
+            String javaType = typeDesc(javaField.genericType)
+            String groovyType = typeDesc(groovyField.genericType)
+            assert javaType == groovyType:
+                "${javaClass.simpleName}.${javaField.name} generic type Java=${javaType} Groovy=${groovyType}"
+        }
+    }
+
+    private static String genericMethodDesc(Method method) {
+        String typeParams = method.typeParameters.length == 0 ? '' :
+            '<' + method.typeParameters.collect { tv ->
+                List<String> bounds = tv.bounds.collect { typeDesc(it) }
+                bounds == ['java.lang.Object'] ? tv.name : tv.name + ' extends ' + bounds.join(' & ')
+            }.join(', ') + '> '
+        String params = method.genericParameterTypes.collect { typeDesc(it) }.join(', ')
+        return typeParams + typeDesc(method.genericReturnType) + ' ' + method.name + '(' + params + ')'
+    }
+
+    private static String rawName(Type type) {
+        if (type instanceof Class) {
+            return ((Class<?>) type).name
+        }
+        if (type instanceof ParameterizedType) {
+            return rawName(((ParameterizedType) type).rawType)
+        }
+        return typeDesc(type)
+    }
+
+    /**
+     * Canonical, JDK-stable description of a reflective {@link Type}. Uses binary
+     * class names and type-variable names rather than {@code Type.toString()}, which
+     * has changed wording across JDK releases.
+     */
+    private static String typeDesc(Type type) {
+        if (type == null) {
+            return 'null'
+        }
+        if (type instanceof Class) {
+            Class<?> c = (Class<?>) type
+            if (c.isArray()) {
+                return typeDesc(c.componentType) + '[]'
+            }
+            return c.name
+        }
+        if (type instanceof TypeVariable) {
+            return ((TypeVariable<?>) type).name
+        }
+        if (type instanceof ParameterizedType) {
+            ParameterizedType p = (ParameterizedType) type
+            Type[] typeArgs = p.actualTypeArguments
+            String raw = typeDesc(p.rawType)
+            if (typeArgs == null || typeArgs.length == 0) {
+                return raw
+            }
+            return raw + '<' + typeArgs.collect { typeDesc(it) }.join(', ') + '>'
+        }
+        if (type instanceof WildcardType) {
+            WildcardType w = (WildcardType) type
+            Type[] lower = w.lowerBounds
+            if (lower != null && lower.length > 0) {
+                return '? super ' + typeDesc(lower[0])
+            }
+            Type[] upper = w.upperBounds
+            if (upper != null && upper.length > 0 && upper[0] != Object) {
+                return '? extends ' + typeDesc(upper[0])
+            }
+            return '?'
+        }
+        if (type instanceof GenericArrayType) {
+            return typeDesc(((GenericArrayType) type).genericComponentType) + '[]'
+        }
+        return String.valueOf(type)
+    }
+
+    /**
+     * Verifies that javac and static Groovy both reject invalid generics code.
+     */
+    private void assertNegativeCompile(String className, String javaSrc, String javaDiagnosticSub, String groovyDiagnosticSub) {
+        JavaShell js = new JavaShell()
+        Throwable javaEx = shouldFail(JavaShellCompilationException) {
+            js.compile(className, javaSrc)
+        }
+        assert javaEx.message.contains(javaDiagnosticSub): "Expected Java diagnostic to contain '$javaDiagnosticSub', but got: ${javaEx.message}"
+
+        Throwable groovyEx = shouldFail(CompilationFailedException) {
+            newStaticGroovyClassLoader().parseClass(toGroovy(javaSrc))
+        }
+        assert groovyEx.message.contains(groovyDiagnosticSub): "Expected Groovy diagnostic to contain '$groovyDiagnosticSub', but got: ${groovyEx.message}"
+    }
+
+    /**
+     * Verifies runtime negative behavior (e.g. heap pollution / ClassCastException on bridge method invocation).
+     */
+    private void assertNegativeRuntime(String className, String javaSrc, Class<? extends Throwable> expectedException) {
+        JavaShell js = new JavaShell()
+        Class<?> javaClass = js.compile(className, javaSrc)
+        InvocationTargetException javaInvocationEx = shouldFail(InvocationTargetException) {
+            javaClass.getMethod('test').invoke(null)
+        }
+        assert expectedException.isInstance(javaInvocationEx.getTargetException()):
+            "Java expected target exception ${expectedException.name}, but got: ${javaInvocationEx.getTargetException()}"
+
+        Class<?> groovyClass = newStaticGroovyClassLoader().parseClass(toGroovy(javaSrc))
+        InvocationTargetException groovyInvocationEx = shouldFail(InvocationTargetException) {
+            groovyClass.getMethod('test').invoke(null)
+        }
+        assert expectedException.isInstance(groovyInvocationEx.getTargetException()):
+            "Groovy expected target exception ${expectedException.name}, but got: ${groovyInvocationEx.getTargetException()}"
+    }
+
+}