Second Approach: rely on the mangled name

Author: biboudis

src/java.base/share/classes/java/lang/reflect/Deconstructor.java

@@ -1,6 +1,9 @@
 package java.lang.reflect;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+
+import static java.lang.runtime.PatternBytecodeName.mangle;
 
 /**
  * {@code Deconstructor} provides information about, and access to, a single
@@ -95,4 +98,9 @@ Deconstructor<T> copy() {
         res.root = this;
         return res;
     }
+
+    private static final String DINIT = "\\^dinit\\_";
+    String getMangledName() {
+        return DINIT + ":" + super.getMangledName();
+    }
 }

src/java.base/share/classes/java/lang/runtime/PatternBootstraps.java

@@ -25,23 +25,14 @@
 
 package java.lang.runtime;
 
-import jdk.internal.constant.ConstantUtils;
 import jdk.internal.misc.PreviewFeatures;
 
-import java.lang.Enum.EnumDesc;
-import java.lang.classfile.ClassFile;
-import java.lang.constant.ClassDesc;
-import java.lang.constant.MethodTypeDesc;
 import java.lang.invoke.*;
 import java.lang.reflect.*;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.*;
-import java.util.function.BiPredicate;
-import java.util.stream.Collectors;
 
-import static java.lang.invoke.MethodHandles.Lookup.ClassOption.NESTMATE;
-import static java.lang.invoke.MethodHandles.Lookup.ClassOption.STRONG;
 import static java.util.Objects.requireNonNull;
 
 /**
@@ -60,6 +51,7 @@ private PatternBootstraps() {
     private static final Object SENTINEL = new Object();
     private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
     private static final boolean previewEnabled = PreviewFeatures.isEnabled();
+    private static final String DINIT = "\\^dinit\\_";
 
     private static class StaticHolders {
         private static final MethodHandle SYNTHETIC_PATTERN;
@@ -97,7 +89,6 @@ private static class StaticHolders {
      * @param invocationType The invocation type of the {@code CallSite} with one parameter,
      *                       a reference type, and an {@code Object} as a return type.
      * @param mangledName    The mangled name of the method declaration that will act as a pattern.
-     * @param needsStatic    Guide the translation
      * @return a {@code CallSite} returning the first matching element as described above
      * @throws NullPointerException     if any argument is {@code null}
      * @throws IllegalArgumentException if the invocation type is not a method type of first parameter of a reference type,
@@ -108,72 +99,101 @@ private static class StaticHolders {
     public static CallSite invokePattern(MethodHandles.Lookup lookup,
                                          String invocationName,
                                          MethodType invocationType,
-                                         String mangledName,
-                                         int needsStatic) {
-        if (invocationType.parameterCount() == 2) {
-            Class<?> receiverType = invocationType.parameterType(0);
-            Class<?> matchCandidateType = invocationType.parameterType(1);
-            if ((!invocationType.returnType().equals(Object.class)))
-                throw new IllegalArgumentException("Illegal invocation type " + invocationType);
-
-            MethodHandle target = null;
-            try {
-                if (needsStatic == 1) {
-                    // Attempt 1: discover the pattern declaration
+                                         String mangledName) {
+        MethodHandle target = null;
+
+        switch (detectPatternUseSite(invocationType, mangledName)) {
+            case Deconstructor -> {
+                Class<?> receiverType = invocationType.parameterType(0);
+                Class<?> matchCandidateType = invocationType.parameterType(1);
+                try {
+                    // Attempt 1: discover the deconstructor
                     target = lookup.findStatic(receiverType, mangledName, MethodType.methodType(Object.class, receiverType, matchCandidateType));
+                } catch (Throwable t) {
+                    // Attempt 2: synthesize the pattern declaration from the record components
+                    if (!matchCandidateType.isRecord() || !receiverType.equals(matchCandidateType)) {
+                        throw new IllegalArgumentException("Implicit deconstructor invocation with erroneous match-candidate type or received type");
+                    }
+
+                    String expectedMangledName = DINIT + ':' + PatternBytecodeName.mangle(matchCandidateType,
+                            Arrays.stream(matchCandidateType.getRecordComponents())
+                                    .map(RecordComponent::getType)
+                                    .toArray(Class<?>[]::new));
+
+                    if (!expectedMangledName.equals(mangledName)) {
+                        throw new IllegalArgumentException("Unexpected deconstructor at use site: " + mangledName + "(was expecting: " + expectedMangledName + ")");
+                    }
+
+                    target = calculateSyntheticPatternMT(invocationType, matchCandidateType);
                 }
-                else {
+            }
+            case InstancePattern -> {
+                Class<?> receiverType = invocationType.parameterType(0);
+                Class<?> matchCandidateType = invocationType.parameterType(1);
+                try {
                     target = lookup.findVirtual(receiverType, mangledName, MethodType.methodType(Object.class, matchCandidateType));
                 }
-                return new ConstantCallSite(target);
-            } catch (Throwable t) {
-                // Attempt 2: synthesize the pattern declaration from the record components
-                if (!matchCandidateType.isRecord() || !receiverType.equals(matchCandidateType)) {
-                    throw new IllegalArgumentException("Implicit pattern invocation with erroneous match-candidate type or received type");
+                catch (Throwable t) {
+                    throw new IllegalArgumentException("Unexpected instance pattern");
                 }
-
-                String expectedMangledName = PatternBytecodeName.mangle(matchCandidateType,
-                        Arrays.stream(matchCandidateType.getRecordComponents())
-                                .map(RecordComponent::getType)
-                                .toArray(Class<?>[]::new));
-
-                if (!expectedMangledName.equals(mangledName)) {
-                    throw new IllegalArgumentException("Unexpected pattern at use site: " + mangledName + "(was expecting: " + expectedMangledName + ")");
+            }
+            case StaticPattern -> {
+                Class<?> matchCandidateType = invocationType.parameterType(0);
+                try {
+                    target = lookup.findStatic(matchCandidateType, mangledName, MethodType.methodType(Object.class, matchCandidateType));
                 }
+                catch (Throwable t) {
+                    throw new IllegalArgumentException("Unexpected static pattern");
+                }
+            }
+        }
 
-                @SuppressWarnings("removal")
-                final RecordComponent[] components = AccessController.doPrivileged(
-                        (PrivilegedAction<RecordComponent[]>) matchCandidateType::getRecordComponents);
+        return new ConstantCallSite(target);
+    }
 
-                Method[] accessors = Arrays.stream(components).map(c -> {
-                    Method accessor = c.getAccessor();
-                    accessor.setAccessible(true);
-                    return accessor;
-                }).toArray(Method[]::new);
+    private static MethodHandle calculateSyntheticPatternMT(MethodType invocationType, Class<?> matchCandidateType) {
+        @SuppressWarnings("removal") final RecordComponent[] components = AccessController.doPrivileged(
+                (PrivilegedAction<RecordComponent[]>) matchCandidateType::getRecordComponents);
 
-                Class<?>[] ctypes = Arrays.stream(components).map(c -> c.getType()).toArray(Class<?>[]::new);
+        Method[] accessors = Arrays.stream(components).map(c -> {
+            Method accessor = c.getAccessor();
+            accessor.setAccessible(true);
+            return accessor;
+        }).toArray(Method[]::new);
 
-                Carriers.CarrierElements carrierElements = Carriers.CarrierFactory.of(ctypes);
+        Class<?>[] ctypes = Arrays.stream(components).map(c -> c.getType()).toArray(Class<?>[]::new);
 
-                MethodHandle initializingConstructor = carrierElements.initializingConstructor();
+        Carriers.CarrierElements carrierElements = Carriers.CarrierFactory.of(ctypes);
 
-                MethodHandle carrierCreator = initializingConstructor.asSpreader(Object[].class, ctypes.length);
+        MethodHandle initializingConstructor = carrierElements.initializingConstructor();
 
-                target =
-                        MethodHandles.dropArguments(
-                                MethodHandles.insertArguments(StaticHolders.SYNTHETIC_PATTERN,
-                                        0,
-                                        accessors,
-                                        carrierCreator),
-                                1,
-                                Object.class).asType(invocationType);
+        MethodHandle carrierCreator = initializingConstructor.asSpreader(Object[].class, ctypes.length);
 
-                return new ConstantCallSite(target);
-            }
-        }
+        return MethodHandles.dropArguments(
+                        MethodHandles.insertArguments(StaticHolders.SYNTHETIC_PATTERN,
+                                0,
+                                accessors,
+                                carrierCreator),
+                        1,
+                        Object.class).asType(invocationType);
+    }
 
-        // todo: static patterns will expect one parameter
-        throw new IllegalStateException("Pattern Invocation Illegal State");
+    enum PatternUseSite {
+        Deconstructor,
+        InstancePattern,
+        StaticPattern
+    }
+    static PatternUseSite detectPatternUseSite(MethodType invocationType,
+                                               String mangledName) {
+        if (invocationType.parameterCount() == 2) {
+            return mangledName.startsWith(DINIT + ':') ? PatternUseSite.Deconstructor : PatternUseSite.InstancePattern;
+        } else if (invocationType.parameterCount() == 1) {
+            return PatternUseSite.StaticPattern;
+        } else if ((!invocationType.returnType().equals(Object.class))) {
+            throw new IllegalArgumentException("Illegal return type: " + invocationType);
+        } else {
+            throw new IllegalArgumentException("Illegal invocation type " + invocationType);
+        }
     }
 
     /**

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

@@ -2099,18 +2099,18 @@ public Name externalName(Types types) {
 
         private Name mangledBytecodePatternName(Types types) {
             List<Type> bindingTypes = ((PatternType) this.type).erasedBindingTypes;
-
-            List<String> parts = bindingTypes.map(type -> {
+            List<String> bindingTypesStringParts = bindingTypes.map(type -> {
                 var g = new UnSharedSignatureGenerator(types);
                 g.assembleSig(type);
                 String mangled = name.table.names.fromString(BytecodeName.toBytecodeName(g.toName(name.table.names).toString())).toString();
                 mangled = mangled.toString().replaceFirst("\\\\=", "");
                 return mangled;
             });
+            String bindingTypesString = String.join(":", bindingTypesStringParts);
 
-            String postFix = String.join(":", parts);
+            String patternNameString = isDeconstructor() ? BytecodeName.toBytecodeName(name.table.names.dinit.toString()) + ":" + owner.name.toString() : name.toString();
 
-            return name.table.names.fromString((isDeconstructor() ? owner.name.toString() : name) + ":" + postFix);
+            return name.table.names.fromString(patternNameString + ":" + bindingTypesString);
         }
 
         static class UnSharedSignatureGenerator extends Types.SignatureGenerator {

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

@@ -538,16 +538,15 @@ private JCMethodInvocation generatePatternCall(JCRecordPattern recordPattern, Bi
         List<Type> staticArgTypes = List.of(syms.methodHandleLookupType,
                 syms.stringType,
                 syms.methodTypeType,
-                syms.stringType,
-                syms.intType);
+                syms.stringType);
 
         MethodSymbol bsm = rs.resolveInternalMethod(
                 recordPattern.pos(), env, syms.patternBootstrapsType,
                 names.invokePattern, staticArgTypes, List.nil());
 
         List<JCExpression> invocationParams = List.of(make.Ident(matchCandidate));
         List<Type> invocationParamTypes;
-        if (true /*is instance pattern*/) {
+        if (true) {
             if (recordPattern.deconstructor instanceof JCFieldAccess acc &&
                     !TreeInfo.isStaticSelector(acc.selected, names)) {
                 invocationParamTypes = List.of(/*receiver:*/acc.selected.type,
@@ -570,10 +569,8 @@ private JCMethodInvocation generatePatternCall(JCRecordPattern recordPattern, Bi
         );
 
         String mangledName = ((MethodSymbol)(recordPattern.patternDeclaration.baseSymbol())).externalName(types).toString();
-        int needsStatic = recordPattern.patternDeclaration.baseSymbol().isStatic() || recordPattern.patternDeclaration.baseSymbol().isDeconstructor() ? 1: 0;
         LoadableConstant[] staticArgValues = new LoadableConstant[] {
-                LoadableConstant.String(mangledName),
-                LoadableConstant.Int(needsStatic)
+                LoadableConstant.String(mangledName)
         };
 
         DynamicMethodSymbol dynSym = new DynamicMethodSymbol(names.invokePattern,

src/jdk.compiler/share/classes/com/sun/tools/javac/util/Names.java

@@ -113,6 +113,7 @@ public static Names instance(Context context) {
     public final Name values;
     public final Name readResolve;
     public final Name readObject;
+    public final Name dinit;
 
     // class names
     public final Name java_io_Serializable;
@@ -314,6 +315,7 @@ public Names(Context context) {
         readResolve = fromString("readResolve");
         readObject = fromString("readObject");
         dollarThis = fromString("$this");
+        dinit = fromString("<dinit>");
 
         // class names
         java_io_Serializable = fromString("java.io.Serializable");

test/jdk/java/lang/runtime/PatternBootstrapsTest.java

@@ -54,10 +54,12 @@
 public class PatternBootstrapsTest {
 
     public static final MethodHandle INVK_PATTERN;
+    private static final String DINIT = "\\^dinit\\_";
+
     static {
         try {
             INVK_PATTERN = MethodHandles.lookup().findStatic(PatternBootstraps.class, "invokePattern",
-                    MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class, String.class, int.class));
+                    MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class, String.class));
         }
         catch (ReflectiveOperationException e) {
             throw new AssertionError("Should not happen", e);
@@ -80,13 +82,13 @@ public pattern R2(int x, int y) {
 
     private void testPatternInvocation(Object target, Class<?> targetType, String mangledName, int componentNo, int result) throws Throwable {
         MethodType dtorType = MethodType.methodType(Object.class, targetType, targetType);
-        MethodHandle indy = ((CallSite) INVK_PATTERN.invoke(MethodHandles.lookup(), "", dtorType, mangledName, 1)).dynamicInvoker();
+        MethodHandle indy = ((CallSite) INVK_PATTERN.invoke(MethodHandles.lookup(), "", dtorType, mangledName)).dynamicInvoker();
         List<MethodHandle> components = Carriers.components(MethodType.methodType(Object.class, int.class, int.class));
         assertEquals((int) components.get(componentNo).invokeExact(indy.invoke(target, target)), result);
     }
 
     public void testPatternInvocations() throws Throwable {
-        testPatternInvocation(new R(1, 2), R.class, "R:I:I", 0, 1);
-        testPatternInvocation(new R2(1, 2), R2.class, "R2:I:I", 0, 1);
+        testPatternInvocation(new R(1, 2), R.class, DINIT + ":R:I:I", 0, 1);
+        testPatternInvocation(new R2(1, 2), R2.class, DINIT + ":R2:I:I", 0, 1);
     }
 }

test/langtools/tools/javac/patterns/declarations/PatternDeclarationsBytecodeTest.java

@@ -94,7 +94,7 @@ public pattern Test(String name, String username) {
                     .run()
                     .getOutput(Task.OutputKind.DIRECT);
 
-            if (!javapOut.contains("public static java.lang.Object Test:Ljava\\|lang\\|String\\?:Ljava\\|lang\\|String\\?(test.Test, test.Test)"))
+            if (!javapOut.contains("public static java.lang.Object \\^dinit\\_:Test:Ljava\\|lang\\|String\\?:Ljava\\|lang\\|String\\?(test.Test, test.Test)"))
                 throw new AssertionError("Wrongly generated signature of pattern declaration:\n" + javapOut);
         }
     }