8294943: Implement record patterns in enhanced for

src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java

@@ -3045,8 +3045,10 @@ else if(peekToken(lookahead, COLON)) {
                 }
                 case LBRACKET:
                     if (peekToken(lookahead, RBRACKET)) {
-                        return ForInitResult.LocalVarDecl;
+                        return inSelectionAndParenthesis ? ForInitResult.RecordPattern
+                                                         : ForInitResult.LocalVarDecl;
                     }
+                    return ForInitResult.LocalVarDecl;
                 case LT:
                     typeParameterPossibleStart = lookahead;
                     break;

test/langtools/tools/javac/patterns/DisambiguatePatterns.java

@@ -35,16 +35,30 @@
 import com.sun.source.tree.ClassTree;
 import com.sun.source.tree.CompilationUnitTree;
 import com.sun.source.tree.ConstantCaseLabelTree;
+import com.sun.source.tree.EnhancedForLoopTree;
 import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.PatternCaseLabelTree;
+import com.sun.source.tree.PatternTree;
+import com.sun.source.tree.StatementTree;
 import com.sun.source.tree.SwitchTree;
+import com.sun.source.tree.Tree.Kind;
 import com.sun.tools.javac.file.JavacFileManager;
 import com.sun.tools.javac.parser.JavacParser;
 import com.sun.tools.javac.parser.ParserFactory;
 import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.main.Option;
+import com.sun.tools.javac.util.Log;
 import com.sun.tools.javac.util.Options;
+import java.net.URI;
+import java.net.URISyntaxException;
 import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import javax.tools.Diagnostic;
+import javax.tools.DiagnosticListener;
+import javax.tools.JavaFileObject;
+import javax.tools.SimpleJavaFileObject;
 
 public class DisambiguatePatterns {
 
@@ -110,14 +124,44 @@ public static void main(String... args) throws Throwable {
                                  ExpressionType.EXPRESSION);
         test.disambiguationTest("a & b",
                                  ExpressionType.EXPRESSION);
+        test.forDisambiguationTest("T[] a", ForType.ENHANCED_FOR);
+        test.forDisambiguationTest("T[].class.getName()", ForType.TRADITIONAL_FOR);
+        test.forDisambiguationTest("T[].class", ForType.TRADITIONAL_FOR, "compiler.err.not.stmt");
+        test.forDisambiguationTest("R(T[] a)", ForType.ENHANCED_FOR_WITH_PATTERNS);
+
+        test.forDisambiguationTest("Point(Integer a, Integer b)", ForType.ENHANCED_FOR_WITH_PATTERNS);
+        test.forDisambiguationTest("ForEachPatterns.Point(Integer a, Integer b)", ForType.ENHANCED_FOR_WITH_PATTERNS);
+        test.forDisambiguationTest("GPoint<Integer>(Integer a, Integer b)", ForType.ENHANCED_FOR_WITH_PATTERNS);
+        test.forDisambiguationTest("@Annot(field = \"test\") Point p", ForType.ENHANCED_FOR);
+        test.forDisambiguationTest("GPoint<Point>(Point(Integer a, Integer b), Point c)", ForType.ENHANCED_FOR_WITH_PATTERNS);
+        test.forDisambiguationTest("GPoint<Point>(Point(var a, Integer b), Point c)", ForType.ENHANCED_FOR_WITH_PATTERNS);
+        test.forDisambiguationTest("GPoint<VoidPoint>(VoidPoint(), VoidPoint())", ForType.ENHANCED_FOR_WITH_PATTERNS);
+        test.forDisambiguationTest("RecordOfLists(List<Integer> lr)", ForType.ENHANCED_FOR_WITH_PATTERNS);
+        test.forDisambiguationTest("RecordOfLists2(List<List<Integer>> lr)", ForType.ENHANCED_FOR_WITH_PATTERNS);
+        test.forDisambiguationTest("GPoint<@Annot(field = \"\") ? extends Point>(var x, var y)", ForType.ENHANCED_FOR_WITH_PATTERNS);
+
+        test.forDisambiguationTest("method()", ForType.TRADITIONAL_FOR);
+        test.forDisambiguationTest("method(), method()", ForType.TRADITIONAL_FOR);
+        test.forDisambiguationTest("method2((Integer a) -> 42)", ForType.TRADITIONAL_FOR);
+        test.forDisambiguationTest("m(cond ? b() : i)", ForType.TRADITIONAL_FOR);
+        test.forDisambiguationTest("m((GPoint<?>)null, cond ? b() : i)", ForType.TRADITIONAL_FOR);
     }
 
     private final ParserFactory factory;
+    private final List<String> errors = new ArrayList<>();
 
-    public DisambiguatePatterns() {
+    public DisambiguatePatterns() throws URISyntaxException {
         Context context = new Context();
+        context.put(DiagnosticListener.class, d -> {
+            if (d.getKind() == Diagnostic.Kind.ERROR) {
+                errors.add(d.getCode());
+            }
+        });
         JavacFileManager jfm = new JavacFileManager(context, true, Charset.defaultCharset());
         Options.instance(context).put(Option.PREVIEW, "");
+        SimpleJavaFileObject source =
+                new SimpleJavaFileObject(new URI("mem://Test.java"), JavaFileObject.Kind.SOURCE) {};
+        Log.instance(context).useSource(source);
         factory = ParserFactory.instance(context);
     }
 
@@ -148,9 +192,66 @@ private void test() {
         }
     }
 
+    void forDisambiguationTest(String snippet, ForType forType, String... expectedErrors) {
+        errors.clear();
+
+        String codeTemplate = switch (forType) {
+            case TRADITIONAL_FOR ->
+                """
+                public class Test {
+                    private void test() {
+                        for (SNIPPET; ;) {
+                        }
+                    }
+                }
+                """;
+            case ENHANCED_FOR, ENHANCED_FOR_WITH_PATTERNS ->
+                """
+                public class Test {
+                    private void test() {
+                        for (SNIPPET : collection) {
+                        }
+                    }
+                }
+                """;
+        };
+
+        String code = codeTemplate.replace("SNIPPET", snippet);
+        JavacParser parser = factory.newParser(code, false, false, false);
+        CompilationUnitTree result = parser.parseCompilationUnit();
+        if (!Arrays.asList(expectedErrors).equals(errors)) {
+            throw new AssertionError("Expected errors: " + Arrays.asList(expectedErrors) +
+                                     ", actual: " + errors +
+                                     ", for: " + code);
+        }
+        ClassTree clazz = (ClassTree) result.getTypeDecls().get(0);
+        MethodTree method = (MethodTree) clazz.getMembers().get(0);
+        StatementTree st = method.getBody().getStatements().get(0);
+        if (forType == ForType.TRADITIONAL_FOR) {
+            if (st.getKind() != Kind.FOR_LOOP) {
+                throw new AssertionError("Unpected statement: " + st);
+            }
+        } else {
+            EnhancedForLoopTree ef = (EnhancedForLoopTree) st;
+            ForType actualType = switch (ef.getVariableOrRecordPattern()) {
+                case PatternTree pattern -> ForType.ENHANCED_FOR_WITH_PATTERNS;
+                default -> ForType.ENHANCED_FOR;
+            };
+            if (forType != actualType) {
+                throw new AssertionError("Expected: " + forType + ", actual: " + actualType +
+                                          ", for: " + code + ", parsed: " + result);
+            }
+        }
+    }
+
     enum ExpressionType {
         PATTERN,
         EXPRESSION;
     }
 
+    enum ForType {
+        TRADITIONAL_FOR,
+        ENHANCED_FOR,
+        ENHANCED_FOR_WITH_PATTERNS;
+    }
 }

test/langtools/tools/javac/patterns/ForEachPatterns.java

@@ -158,39 +158,6 @@ static int applicability2(List<Object> points) {
         return -1;
     }
 
-    static void m(int i) { }
-    static void m(GPoint<?> gpoint, int i) { }
-    static int b() { return 42; }
-
-    static void forParsing(int i, boolean cond) {
-        List<Point>                 points = null;
-        List<GPoint<Integer>>       generic_points = null;
-        List<GPoint<Point>>         generic_points_nested = null;
-        List<GPoint<VoidPoint>>     generic_vpoints_nested = null;
-        List<RecordOfLists>         list_of_records = null;
-        List<RecordOfLists2>        list_of_records2 = null;
-
-        for (Point(Integer a, Integer b) : points) { }
-        for (ForEachPatterns.Point(Integer a, Integer b) : points) { }
-        for (GPoint<Integer>(Integer a, Integer b) : generic_points) { }
-        for (@Annot(field = "test") Point p : points) {}
-        for (method(); i == 0;) { i++; }
-        for (method(), method(); i == 0;) { i++; }
-        for (ForEachPatterns.<Integer>method(); i == 0;) { i++; }
-        for (GPoint<Point>(Point(Integer a, Integer b), Point c) : generic_points_nested) { }
-        for (GPoint<Point>(Point(var a, Integer b), Point c) : generic_points_nested) { }
-        for (GPoint<VoidPoint>(VoidPoint(), VoidPoint()) : generic_vpoints_nested) { }
-        for (method2((Integer a) -> 42); i == 0;) { i++; }
-        for (RecordOfLists(List<Integer> lr) : list_of_records) {}
-        for (RecordOfLists2(List<List<Integer>> lr) : list_of_records2) {}
-        for (m(cond ? b() : i) ; i == 0;) {}
-        for (m((GPoint<?>)null, cond ? b() : i) ; ;) {}
-//        for (GPoint<@Annot(field = "") ? extends Point>(var x, var y) : generic_points_nested) {}; // TODO: Enable after https://bugs.openjdk.org/browse/JDK-8297602 is fixed
-    }
-    //where
-    static <T> void method() {}
-    static <T> void method2(Function<Integer, Integer> f) {}
-
     static List<Color> JEPExample() {
         Rectangle rect = new Rectangle(
                 new ColoredPoint(new Point(1,2), Color.RED),