8337161: Support record pattern for generic records

src/java.base/share/classes/java/lang/reflect/code/type/impl/FieldRefImpl.java

@@ -113,7 +113,7 @@ static Class<?> resolve(MethodHandles.Lookup l, TypeElement t) throws Reflective
 
     @Override
     public String toString() {
-        return refType + "::" + name + "()" + type;
+        return refType.externalize() + "::" + name + "()" + type.externalize();
     }
 
     @Override

src/java.base/share/classes/java/lang/reflect/code/type/impl/MethodRefImpl.java

@@ -139,9 +139,9 @@ static Class<?> resolve(MethodHandles.Lookup l, TypeElement t) throws Reflective
 
     @Override
     public String toString() {
-        return refType + "::" + name +
-            type.parameterTypes().stream().map(TypeElement::toString)
-                    .collect(joining(", ", "(", ")")) + type.returnType();
+        return refType.externalize() + "::" + name +
+            type.parameterTypes().stream().map(t -> t.externalize().toString())
+                    .collect(joining(", ", "(", ")")) + type.returnType().externalize();
     }
 
     @Override

src/java.base/share/classes/java/lang/reflect/code/type/impl/RecordTypeRefImpl.java

@@ -64,9 +64,9 @@ public MethodRef methodForComponent(int i) {
     @Override
     public String toString() {
         return components.stream()
-                .map(c -> c.type().toString() + " " + c.name())
+                .map(c -> c.type().externalize() + " " + c.name())
                 .collect(joining(", ", "(", ")")) +
-                recordType.toString();
+                recordType.externalize();
     }
 
 }

test/jdk/java/lang/reflect/code/TestPatterns2.java

@@ -0,0 +1,50 @@
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Method;
+import java.lang.reflect.code.OpTransformer;
+import java.lang.reflect.code.interpreter.Interpreter;
+import java.lang.reflect.code.op.CoreOp;
+import java.lang.runtime.CodeReflection;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/*
+ * @test
+ * @run testng TestPatterns2
+ * @enablePreview
+ */
+public class TestPatterns2 {
+
+    record R<T extends Number> (T n) {}
+
+    @CodeReflection
+    static boolean f(Object o) {
+        return o instanceof R(Integer i);
+    }
+
+    @Test
+    void test() {
+
+        CoreOp.FuncOp f = getFuncOp("f");
+        f.writeTo(System.out);
+
+        CoreOp.FuncOp lf = f.transform(OpTransformer.LOWERING_TRANSFORMER);
+        lf.writeTo(System.out);
+
+        R[] args = {new R(1), new R(2d)};
+        for (R arg : args) {
+            Assert.assertEquals(Interpreter.invoke(MethodHandles.lookup(), lf, arg), f(arg));
+        }
+    }
+
+    static CoreOp.FuncOp getFuncOp(String name) {
+        Optional<Method> om = Stream.of(TestPatterns2.class.getDeclaredMethods())
+                .filter(m -> m.getName().equals(name))
+                .findFirst();
+
+        Method m = om.get();
+        return m.getCodeModel().get();
+    }
+}

test/jdk/java/lang/reflect/code/type/TestReferences.java

@@ -50,15 +50,16 @@ public Object[][] methodRefs() {
                 {"java.io.PrintStream::println(java.lang.String)void", "java.io.PrintStream", "println"},
                 {"MethodReferenceTest$A::m(java.lang.Object)java.lang.Object", "MethodReferenceTest$A", "m"},
                 {"MethodReferenceTest$X::<new>(int)MethodReferenceTest$X", "MethodReferenceTest$X", "<new>"},
-                {"MethodReferenceTest$A[]::<new>(int)MethodReferenceTest$A[]", "MethodReferenceTest$A[]", "<new>"}
+                {"MethodReferenceTest$A[]::<new>(int)MethodReferenceTest$A[]", "MethodReferenceTest$A[]", "<new>"},
+                {"R<#R::T<java.lang.Number>>::n()#R::T<java.lang.Number>", "R<#R::T<java.lang.Number>>", "n"}
         };
     }
 
     @Test(dataProvider = "methodRefs")
     public void testMethodRef(String mds, String refType, String name) {
         MethodRef mr = MethodRef.ofString(mds);
         Assert.assertEquals(mr.toString(), mds);
-        Assert.assertEquals(mr.refType().toString(), refType);
+        Assert.assertEquals(mr.refType().externalize().toString(), refType);
         Assert.assertEquals(mr.name(), name);
     }
 
@@ -69,16 +70,17 @@ public Object[][] fieldRefs() {
                 {"a.b::c()int", "a.b", "c", "int"},
                 {"a.b.c::d()int", "a.b.c", "d", "int"},
                 {"java.lang.System::out()java.io.PrintStream", "java.lang.System", "out", "java.io.PrintStream"},
+                {"R<#R::T<java.lang.Number>>::n()#R::T<java.lang.Number>", "R<#R::T<java.lang.Number>>", "n", "#R::T<java.lang.Number>"}
         };
     }
 
     @Test(dataProvider = "fieldRefs")
     public void testFieldRef(String fds, String refType, String name, String type) {
         FieldRef fr = FieldRef.ofString(fds);
         Assert.assertEquals(fr.toString(), fds);
-        Assert.assertEquals(fr.refType().toString(), refType);
+        Assert.assertEquals(fr.refType().externalize().toString(), refType);
         Assert.assertEquals(fr.name(), name);
-        Assert.assertEquals(fr.type().toString(), type);
+        Assert.assertEquals(fr.type().externalize().toString(), type);
     }
 
 
@@ -89,6 +91,7 @@ public Object[][] recordTypeRefs() {
                 {"(B b)A"},
                 {"(B b, C c)A"},
                 {"(p.Func<String, Number> f, Entry<List<String>, val> e, int i, long l)p.A<R>"},
+                {"(#R::T<java.lang.Number> n)R<#R::T<java.lang.Number>>"}
         };
     }
 

test/langtools/tools/javac/reflect/PatternTest2.java

@@ -0,0 +1,35 @@
+import java.lang.runtime.CodeReflection;
+
+/*
+ * @test
+ * @build PatternTest2
+ * @build CodeReflectionTester
+ * @run main CodeReflectionTester PatternTest2
+ */
+public class PatternTest2 {
+    record R<T extends Number> (T n) {}
+
+    @IR("""
+            func @"f" (%0 : java.lang.Object)boolean -> {
+                %1 : Var<java.lang.Object> = var %0 @"o";
+                %2 : java.lang.Object = var.load %1;
+                %3 : java.lang.Integer = constant @null;
+                %4 : Var<java.lang.Integer> = var %3 @"i";
+                %5 : boolean = pattern.match %2
+                    ()java.lang.reflect.code.ExtendedOp$Pattern$Record<PatternTest2$R<#PatternTest2$R::T<java.lang.Number>>> -> {
+                        %6 : java.lang.reflect.code.ExtendedOp$Pattern$Type<java.lang.Integer> = pattern.type @"i";
+                        %7 : java.lang.reflect.code.ExtendedOp$Pattern$Record<PatternTest2$R<#PatternTest2$R::T<java.lang.Number>>> = pattern.record %6 @"(#PatternTest2$R::T<java.lang.Number> n)PatternTest2$R<#PatternTest2$R::T<java.lang.Number>>";
+                        yield %7;
+                    }
+                    (%8 : java.lang.Integer)void -> {
+                        var.store %4 %8;
+                        yield;
+                    };
+                return %5;
+            };
+            """)
+    @CodeReflection
+    static boolean f(Object o) {
+        return o instanceof R(Integer i);
+    }
+}