First round of instance patterns. No patterns with separate instance and match candidate yet. (openjdk#20)

* First round of instance patterns. No patterns with separate instance and match candidate yet.

* A very (VERY!) basic support for instance pattern with split receiver and match candidate.

* Align calling convention between instance patterns and deconstructors

* Fix adjustment of `syntheticPattern` computation

---------

Co-authored-by: Angelos Bimpoudis <angelos.bimpoudis@oracle.com>

Author: lahodaj

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

@@ -54,7 +54,8 @@
  */
 public class PatternBootstraps {
 
-    private PatternBootstraps() {}
+    private PatternBootstraps() {
+    }
 
     private static final Object SENTINEL = new Object();
     private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
@@ -67,8 +68,7 @@ private static class StaticHolders {
             try {
                 SYNTHETIC_PATTERN = LOOKUP.findStatic(PatternBootstraps.class, "syntheticPattern",
                         MethodType.methodType(Object.class, Method[].class, MethodHandle.class, Object.class));
-            }
-            catch (ReflectiveOperationException e) {
+            } catch (ReflectiveOperationException e) {
                 throw new ExceptionInInitializerError(e);
             }
         }
@@ -97,13 +97,10 @@ 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.
-     *
      * @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,
      *                                  and with {@code Object} as its return type,
-     *
      * @jvms 4.4.6 The CONSTANT_NameAndType_info Structure
      * @jvms 4.4.10 The CONSTANT_Dynamic_info and CONSTANT_InvokeDynamic_info Structures
      */
@@ -113,69 +110,64 @@ public static CallSite invokePattern(MethodHandles.Lookup lookup,
                                          String mangledName) {
         if (invocationType.parameterCount() == 2) {
             Class<?> receiverType = invocationType.parameterType(0);
-            Class<?> selectorType = invocationType.parameterType(1);
+            Class<?> matchCandidateType = invocationType.parameterType(1);
             if ((!invocationType.returnType().equals(Object.class)))
                 throw new IllegalArgumentException("Illegal invocation type " + invocationType);
 
             MethodHandle target = null;
             try {
                 // Attempt 1: discover the pattern declaration
-                target = lookup.findStatic(receiverType, mangledName, MethodType.methodType(Object.class, receiverType, selectorType));
+                target = lookup.findStatic(receiverType, mangledName, MethodType.methodType(Object.class, receiverType, matchCandidateType));
 
                 return new ConstantCallSite(target);
             } catch (Throwable t) {
-                throw new IllegalArgumentException("Cannot find a pattern");
-            }
-        }
+                // 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");
+                }
 
-        Class<?> selectorType = invocationType.parameterType(0);
-        if (invocationType.parameterCount() != 1
-            || (!invocationType.returnType().equals(Object.class)))
-            throw new IllegalArgumentException("Illegal invocation type " + invocationType);
-
-        MethodHandle target = null;
-        try {
-            // Attempt 1: discover the pattern declaration
-            target = lookup.findStatic(selectorType, mangledName, MethodType.methodType(Object.class, selectorType));
-
-            return new ConstantCallSite(target);
-        } catch (Throwable t) {
-            // Attempt 2: synthesize the pattern declaration from the record components
-            if (!selectorType.isRecord()) {
-                throw new IllegalArgumentException("Cannot find a pattern");
-            }
-
-            String expectedMangledName = PatternBytecodeName.mangle(selectorType,
-                    Arrays.stream(selectorType.getRecordComponents())
-                    .map(RecordComponent::getType)
-                    .toArray(Class<?>[]::new));
+                String expectedMangledName = PatternBytecodeName.mangle(matchCandidateType,
+                        Arrays.stream(matchCandidateType.getRecordComponents())
+                                .map(RecordComponent::getType)
+                                .toArray(Class<?>[]::new));
 
-            if (!expectedMangledName.equals(mangledName)) {
-                throw new IllegalArgumentException("\nUnexpected pattern at use site: " + mangledName + "\nWas expecting: " + expectedMangledName);
-            }
+                if (!expectedMangledName.equals(mangledName)) {
+                    throw new IllegalArgumentException("Unexpected pattern at use site: " + mangledName + "(was expecting: " + expectedMangledName + ")");
+                }
 
-            @SuppressWarnings("removal")
-            final RecordComponent[] components = AccessController.doPrivileged(
-                    (PrivilegedAction<RecordComponent[]>) selectorType::getRecordComponents);
+                @SuppressWarnings("removal")
+                final RecordComponent[] components = AccessController.doPrivileged(
+                        (PrivilegedAction<RecordComponent[]>) matchCandidateType::getRecordComponents);
 
-            Method[] accessors = Arrays.stream(components).map(c -> {
-                Method accessor = c.getAccessor();
-                accessor.setAccessible(true);
-                return accessor;
-            }).toArray(Method[]::new);
+                Method[] accessors = Arrays.stream(components).map(c -> {
+                    Method accessor = c.getAccessor();
+                    accessor.setAccessible(true);
+                    return accessor;
+                }).toArray(Method[]::new);
 
-            Class<?>[] ctypes = Arrays.stream(components).map(c -> c.getType()).toArray(Class<?>[]::new);
+                Class<?>[] ctypes = Arrays.stream(components).map(c -> c.getType()).toArray(Class<?>[]::new);
 
-            Carriers.CarrierElements carrierElements = Carriers.CarrierFactory.of(ctypes);
+                Carriers.CarrierElements carrierElements = Carriers.CarrierFactory.of(ctypes);
 
-            MethodHandle initializingConstructor = carrierElements.initializingConstructor();
+                MethodHandle initializingConstructor = carrierElements.initializingConstructor();
 
-            MethodHandle carrierCreator = initializingConstructor.asSpreader(Object[].class, ctypes.length);
+                MethodHandle carrierCreator = initializingConstructor.asSpreader(Object[].class, ctypes.length);
 
-            target = MethodHandles.insertArguments(StaticHolders.SYNTHETIC_PATTERN, 0, accessors, carrierCreator).asType(invocationType);
+                target =
+                        MethodHandles.dropArguments(
+                                MethodHandles.insertArguments(StaticHolders.SYNTHETIC_PATTERN,
+                                        0,
+                                        accessors,
+                                        carrierCreator),
+                                1,
+                                Object.class).asType(invocationType);
 
-            return new ConstantCallSite(target);
+                return new ConstantCallSite(target);
+            }
         }
+
+        // todo: static patterns will expect one parameter
+        throw new IllegalStateException("Pattern Invocation Illegal State");
     }
 
     /**
@@ -184,9 +176,8 @@ public static CallSite invokePattern(MethodHandles.Lookup lookup,
      *
      * @param matchCandidateInstance the receiver of a pattern
      * @param matchCandidateType     the type of the match candidate
-     * @return                       initialized carrier object
-     *
-     * @throws Throwable            throws if invocation of synthetic pattern fails
+     * @return initialized carrier object
+     * @throws Throwable throws if invocation of synthetic pattern fails
      */
     private static Object syntheticPattern(Method[] accessors, MethodHandle carrierCreator, Object matchCandidateInstance) throws Throwable {
         Object[] extracted = Arrays.stream(accessors).map(accessor -> {

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

@@ -366,7 +366,10 @@ public Type externalType(Types types) {
                                   t.getThrownTypes(),
                                   t.tsym);
         } else if ((flags() & PATTERN) != 0) {
-            return new MethodType(List.of(owner.erasure(types)), types.syms.objectType, List.nil(), t.tsym);
+            MethodSymbol thisAsMethod = (MethodSymbol) this;
+            List<Type> parameterTypes = thisAsMethod.getParameters().map(p -> types.erasure(p.type));
+
+            return new MethodType(parameterTypes, types.syms.objectType, List.nil(), t.tsym);
         } else {
             return t;
         }
@@ -480,6 +483,11 @@ public boolean isDeconstructor() {
         return isPattern() && name == owner.name;
     }
 
+    public boolean isTotalPattern() {
+        //TODO: some non-deconstructor patterns can also be total, to be implemented.
+        return isDeconstructor() && (flags() & PARTIAL) == 0;
+    }
+
     public boolean isDynamic() {
         return false;
     }
@@ -2102,7 +2110,7 @@ private Name mangledBytecodePatternName(Types types) {
 
             String postFix = String.join(":", parts);
 
-            return name.table.names.fromString(owner.name.toString() + ":" + postFix);
+            return name.table.names.fromString((isDeconstructor() ? owner.name.toString() : name) + ":" + postFix);
         }
 
         static class UnSharedSignatureGenerator extends Types.SignatureGenerator {

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

@@ -1970,7 +1970,7 @@ public String toString() {
             StringBuilder sb = new StringBuilder();
             appendAnnotationsString(sb);
             sb.append("(out ");
-            sb.append(bindingtypes.stream().map(String::valueOf).collect(Collectors.joining(", out")));
+            sb.append(bindingtypes.stream().map(String::valueOf).collect(Collectors.joining(", out ")));
             sb.append(')');
             return sb.toString();
         }

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

@@ -1208,6 +1208,7 @@ public void visitMethodDef(JCMethodDecl tree) {
             }
 
             if (m.isDeconstructor()) {
+                //TODO: for instance/named patterns
                 m.patternFlags.add(PatternFlags.DECONSTRUCTOR);
                 if ((tree.mods.flags & Flags.PARTIAL) == 0) {
                     m.patternFlags.add(PatternFlags.TOTAL);
@@ -2472,7 +2473,7 @@ public void visitMatch(JCMatch tree) {
 
     @Override
     public void visitMatchFail(JCMatchFail tree) {
-        if ((env.enclMethod.sym.flags_field & Flags.PARTIAL) == 0) {
+        if (env.enclMethod.sym.isTotalPattern()) {
             log.error(tree.pos(), Errors.UnmarkedPartialDeconstructor);
         }
         result = null;
@@ -4349,31 +4350,51 @@ public void visitBindingPattern(JCBindingPattern tree) {
     @Override
     public void visitRecordPattern(JCRecordPattern tree) {
         Type site;
+        Type uncapturedSite;
+        Name deconstructorName;
 
         if (tree.deconstructor == null) {
             log.error(tree.pos(), Errors.DeconstructionPatternVarNotAllowed);
             tree.record = syms.errSymbol;
-            site = tree.type = types.createErrorType(tree.record.type);
+            uncapturedSite = site = tree.type = types.createErrorType(tree.record.type);
+            deconstructorName = names.empty;
         } else {
-            Type type = attribType(tree.deconstructor, env);
-            if (type.isRaw() && type.tsym.getTypeParameters().nonEmpty()) {
-                Type inferred = infer.instantiatePatternType(resultInfo.pt, type.tsym);
-                if (inferred == null) {
-                    log.error(tree.pos(), Errors.PatternTypeCannotInfer);
-                } else {
-                    type = inferred;
+            //TODO: if there's a deconstructor and instance pattern with the same name, which one prevails?
+            if (deferredAttr.attribSpeculative(tree.deconstructor, env, new ResultInfo(KindSelector.TYP, Type.noType)).type.hasTag(TypeTag.CLASS)) {
+                Type type = attribType(tree.deconstructor, env);
+                if (type.isRaw() && type.tsym.getTypeParameters().nonEmpty()) {
+                    Type inferred = infer.instantiatePatternType(resultInfo.pt, type.tsym);
+                    if (inferred == null) {
+                        log.error(tree.pos(), Errors.PatternTypeCannotInfer);
+                    } else {
+                        type = inferred;
+                    }
                 }
+                uncapturedSite = type;
+                site = types.capture(type);
+                deconstructorName = TreeInfo.name(tree.deconstructor);
+            } else if (tree.deconstructor instanceof JCFieldAccess acc) {
+                Type type = attribTree(acc.selected, env, new ResultInfo(KindSelector.VAL_TYP, Type.noType));
+                site = type; //TODO: capture?
+                uncapturedSite = type;
+                deconstructorName = acc.name;
+            } else if (tree.deconstructor instanceof JCIdent ident) {
+                Type type = pt();
+                site = type; //TODO: capture?
+                uncapturedSite = type;
+                deconstructorName = ident.name;
+            } else {
+                //TODO: error recovery
+                throw Assert.error("Not handled.");
             }
-            tree.type = tree.deconstructor.type = type;
-            site = types.capture(tree.type);
         }
 
         List<Type> nestedPatternsTargetTypes = null;
 
         if (site.tsym.kind == Kind.TYP) {
             int nestedPatternCount = tree.nested.size();
 
-            List<MethodSymbol> candidates = candidatesWithArity(site, nestedPatternCount);
+            List<MethodSymbol> candidates = candidatesWithArity(site, deconstructorName, nestedPatternCount);
 
             if (candidates.size() >= 1) {
                 List<Type> notionalTypes = calculateNotionalTypes(tree);
@@ -4427,6 +4448,12 @@ public void visitRecordPattern(JCRecordPattern tree) {
         } finally {
             localEnv.info.scope.leave();
         }
+        //TODO: are these types sensible?
+        if (tree.patternDeclaration != null && tree.patternDeclaration.getParameters().size() == 1) { // TODO: improve error recovery
+            tree.type = tree.deconstructor.type = tree.patternDeclaration.getParameters().head.type;
+        } else {
+            tree.type = tree.deconstructor.type = uncapturedSite;
+        }
         chk.validate(tree.deconstructor, env, true);
         result = tree.type;
         matchBindings = new MatchBindings(outBindings.toList(), List.nil());
@@ -4648,9 +4675,9 @@ private boolean isApplicable(List<Type> patternDeclarationBindingType, List<Type
      * @param nestedPatternCount the number of nested patterns
      * @return                   a list of MethodSymbols
      */
-    private List<MethodSymbol> candidatesWithArity(Type site, int nestedPatternCount) {
+    private List<MethodSymbol> candidatesWithArity(Type site, Name deconstructorName, int nestedPatternCount) {
         var matchersIt = site.tsym.members()
-                .getSymbols(sym -> sym.isPattern() && sym.type.getBindingTypes().size() == nestedPatternCount)
+                .getSymbolsByName(deconstructorName, sym -> sym.isPattern() && sym.type.getBindingTypes().size() == nestedPatternCount)
                 .iterator();
 
         List<MethodSymbol> patternDeclarations = Stream.generate(() -> null)
@@ -4674,11 +4701,11 @@ private List<MethodSymbol> candidatesWithArity(Type site, int nestedPatternCount
                         .collect(List.collector());
                 PatternType pt = new PatternType(recordComponents, erasedComponents, syms.voidType, syms.methodClass);
 
-                MethodSymbol synthetized = new MethodSymbol(PUBLIC | SYNTHETIC | PATTERN, ((ClassSymbol) site.tsym).name, pt, site.tsym);
+                MethodSymbol synthesized = new MethodSymbol(PUBLIC | SYNTHETIC | PATTERN, ((ClassSymbol) site.tsym).name, pt, site.tsym);
 
-                synthetized.patternFlags.add(PatternFlags.DECONSTRUCTOR);
-                synthetized.patternFlags.add(PatternFlags.TOTAL);
-                patternDeclarations = patternDeclarations.prepend(synthetized);
+                synthesized.patternFlags.add(PatternFlags.DECONSTRUCTOR);
+                synthesized.patternFlags.add(PatternFlags.TOTAL);
+                patternDeclarations = patternDeclarations.prepend(synthesized);
             }
         }
 

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

@@ -4878,6 +4878,10 @@ private boolean patternDominated(JCPattern existingPattern, JCPattern currentPat
                     if (existingNested.size() != currentNested.size()) {
                         return false;
                     }
+                    if (!existingRecordPattern.patternDeclaration.isTotalPattern()) {
+                        //partial patterns cannot dominate(?)
+                        return false;
+                    }
                     while (existingNested.nonEmpty()) {
                         if (!patternDominated(existingNested.head, currentNested.head)) {
                             return false;

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

@@ -157,7 +157,8 @@ Type signature(MethodSymbol msym,
             thrownbuf.append(exc);
         }
         if (msym.isPattern()) {
-            Assert.check(params.isEmpty());
+            //TODO: anything to do with the params?
+            //Assert.check(params.isEmpty());
             var erasedBindingTypes = bindingsbuf.toList()
                             .stream()
                             .map(b -> types.erasure(b))

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

@@ -534,7 +534,7 @@ private UnrolledRecordPattern unrollRecordPattern(JCRecordPattern recordPattern)
         return new UnrolledRecordPattern((JCBindingPattern) make.BindingPattern(recordBindingVar).setType(recordBinding.type), guard);
     }
 
-    private JCMethodInvocation generatePatternCall(JCRecordPattern recordPattern, BindingSymbol tempBind) {
+    private JCMethodInvocation generatePatternCall(JCRecordPattern recordPattern, BindingSymbol matchCandidate) {
         List<Type> staticArgTypes = List.of(syms.methodHandleLookupType,
                 syms.stringType,
                 syms.methodTypeType,
@@ -544,8 +544,26 @@ private JCMethodInvocation generatePatternCall(JCRecordPattern recordPattern, Bi
                 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 (recordPattern.deconstructor instanceof JCFieldAccess acc &&
+                    !TreeInfo.isStaticSelector(acc.selected, names)) {
+                invocationParamTypes = List.of(/*receiver:*/acc.selected.type,
+                                               /*match candidate:*/recordPattern.type);
+                invocationParams = invocationParams.prepend(acc.selected);
+            } else {
+                invocationParamTypes = List.of(/*receiver:*/recordPattern.type,
+                                               /*match candidate:*/recordPattern.type);
+                invocationParams = invocationParams.prepend(make.Ident(matchCandidate));
+            }
+        }
+//        else { // this will be needed for static patterns later
+//            invocationParamTypes = List.of(recordPattern.type);
+//        }
         MethodType indyType = new MethodType(
-                List.of(recordPattern.type),
+                invocationParamTypes,
                 syms.objectType,
                 List.nil(),
                 syms.methodClass
@@ -567,7 +585,7 @@ private JCMethodInvocation generatePatternCall(JCRecordPattern recordPattern, Bi
         qualifier.type = syms.objectType;
         return make.Apply(List.nil(),
                         qualifier,
-                        List.of(make.Ident(tempBind)))
+                        invocationParams)
                 .setType(syms.objectType);
     }