/*
 * Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @bug 8205418 8207229 8207230 8230847 8245786 8247334 8248641 8240658 8246774 8274347
 * @summary Test the outcomes from Trees.getScope
 * @modules jdk.compiler/com.sun.tools.javac.api
 *          jdk.compiler/com.sun.tools.javac.comp
 *          jdk.compiler/com.sun.tools.javac.tree
 *          jdk.compiler/com.sun.tools.javac.util
 */

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import javax.lang.model.element.Element;
import javax.tools.JavaCompiler;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

import com.sun.source.tree.AnnotationTree;
import com.sun.source.tree.BlockTree;
import com.sun.source.tree.ClassTree;
import com.sun.source.tree.CompilationUnitTree;
import com.sun.source.tree.ConditionalExpressionTree;
import com.sun.source.tree.IdentifierTree;
import com.sun.source.tree.LambdaExpressionTree;
import com.sun.source.tree.MethodInvocationTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.tree.Scope;
import com.sun.source.tree.Tree;
import com.sun.source.tree.VariableTree;
import com.sun.source.util.JavacTask;
import com.sun.source.util.TaskEvent;
import com.sun.source.util.TaskListener;
import com.sun.source.util.TreePath;
import com.sun.source.util.TreePathScanner;
import com.sun.source.util.Trees;
import com.sun.tools.javac.api.JavacScope;
import com.sun.tools.javac.api.JavacTaskImpl;

import com.sun.tools.javac.api.JavacTool;
import com.sun.tools.javac.comp.Analyzer;
import com.sun.tools.javac.comp.AttrContext;
import com.sun.tools.javac.comp.Env;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.JCTree.JCCase;
import com.sun.tools.javac.tree.JCTree.JCStatement;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Context.Factory;

import static javax.tools.JavaFileObject.Kind.SOURCE;

public class TestGetScopeResult {
    public static void main(String... args) throws IOException {
        new TestGetScopeResult().run();
        new TestGetScopeResult().testAnalyzerDisabled();
        new TestGetScopeResult().testVariablesInSwitch();
        new TestGetScopeResult().testMemberRefs();
        new TestGetScopeResult().testAnnotations();
        new TestGetScopeResult().testAnnotationsLazy();
        new TestGetScopeResult().testCircular();
        new TestGetScopeResult().testRecord();
        new TestGetScopeResult().testLocalRecordAnnotation();
        new TestGetScopeResult().testRuleCases();
        new TestGetScopeResult().testNestedSwitchExpression();
    }

    public void run() throws IOException {
        String[] simpleLambda = {
            "s:java.lang.String",
            "i:Test.I",
            "super:java.lang.Object",
            "this:Test"
        };
        doTest("class Test { void test() { I i = s -> { }; } interface I { public void test(String s); } }",
               simpleLambda);
        doTest("class Test { void test() { I i = s -> { }; } interface I { public int test(String s); } }",
               simpleLambda);
        doTest("class Test { void test() { I i = s -> { }; } interface I { public String test(String s); } }",
               simpleLambda);
        doTest("class Test { void test() { I i; inv(s -> { }); } void inv(I i) { } interface I { public void test(String s); } }",
               simpleLambda);
        doTest("class Test { void test() { I i; inv(s -> { }); } void inv(I i) { } interface I { public int test(String s); } }",
               simpleLambda);
        doTest("class Test { void test() { I i; inv(s -> { }); } void inv(I i) { } interface I { public String test(String s); } }",
               simpleLambda);
        String[] dualLambda = {
            "s:java.lang.String",
            "i:Test.I1",
            "super:java.lang.Object",
            "this:Test",
            "s:java.lang.CharSequence",
            "i:Test.I1",
            "super:java.lang.Object",
            "this:Test"
        };
        doTest("class Test { void test() { I1 i; inv(s -> { }, s -> { }); } void inv(I1 i, I2 i) { } interface I1 { public String test(String s); } interface I2 { public void test(CharSequence s); } }",
               dualLambda);
        doTest("class Test { void test() { I1 i; inv(s -> { }, s -> { }); } void inv(I1 i, I2 i) { } interface I1 { public String test(String s); } interface I2 { public int test(CharSequence s); } }",
               dualLambda);
        String[] brokenType = {
            "s:<any>",
            "u:Undefined",
            "super:java.lang.Object",
            "this:Test"
        };
        doTest("class Test { void test() { Undefined u = s -> { }; } }",
               brokenType);
        String[] multipleCandidates1 = {
            "s:<any>",
            "super:java.lang.Object",
            "this:Test"
        };
        doTest("class Test { void test() { cand1(s -> { }); } void cand1(I1 i) { } void cand1(I2 i) { } interface I1 { public String test(String s); } interface I2 { public int test(CharSequence s); } }",
               multipleCandidates1);
        String[] multipleCandidates2 = {
            "s:java.lang.String",
            "super:java.lang.Object",
            "this:Test"
        };
        doTest("class Test { void test() { cand1(s -> { }); } void cand1(I1 i) { } void cand1(I2 i, int i) { } interface I1 { public String test(String s); } interface I2 { public int test(CharSequence s); } }",
               multipleCandidates2);

        String[] implicitExplicitConflict1 = {
            "<error>:t",
            "s:java.lang.String",
            "super:java.lang.Object",
            "this:Test"
        };

        doTest("class Test { void test() { cand((var s, t) -> \"\"); } void cand(I i) { } interface I { public String test(String s); }  }",
               implicitExplicitConflict1);

        String[] implicitExplicitConflict2 = {
            "s:none",
            "<error>:t",
            "super:java.lang.Object",
            "this:Test"
        };

        doTest("class Test { void test() { cand((t, var s) -> \"\"); } void cand(I i) { } interface I { public String test(String s); }  }",
               implicitExplicitConflict2);

        String[] noFunctionInterface = {
            "s:none",
            "<error>:t",
            "super:java.lang.Object",
            "this:Test"
        };

        doTest("class Test { void test() { cand((t, var s) -> \"\"); } void cand(String s) { } }",
               noFunctionInterface);

        String[] invocationInMethodInvocation = {
            "d2:java.lang.Double",
            "d1:java.lang.Double",
            "super:java.lang.Object",
            "this:Test"
        };

        doTest("""
               class Test {
                   void test() { test(reduce(0.0, (d1, d2) -> 0)); }
                   void test(int i) {}
                   <T> T reduce(T t, BiFunction<T, T, T> f1) {}
                   static interface BiFunction<R, P, Q> {
                       R apply(P p, Q q);
                   }
               }""",
               invocationInMethodInvocation);

        String[] infer = {
            "c:java.lang.String",
            "super:java.lang.Object",
            "this:Test"
        };

        doTest("class Test { void test() { cand(\"\", c -> { }); } <T>void cand(T t, I<T> i) { } interface I<T> { public String test(T s); }  }",
               infer);
        doTest("class Test { void test() { cand(\"\", c -> { }); } <T>void cand(T t, I<T> i, int j) { } interface I<T> { public void test(T s); }  }",
               infer);
        doTest("class Test { void test() { cand(\"\", c -> { }); } <T>void cand(T t, I<T> i, int j) { } interface I<T> { public String test(T s); }  }",
               infer);
    }

    public void doTest(String code, String... expected) throws IOException {
        JavaCompiler c = ToolProvider.getSystemJavaCompiler();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            class MyFileObject extends SimpleJavaFileObject {
                MyFileObject() {
                    super(URI.create("myfo:///Test.java"), SOURCE);
                }
                @Override
                public String getCharContent(boolean ignoreEncodingErrors) {
                    return code;
                }
            }
            JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null, List.of(new MyFileObject()));
            CompilationUnitTree cut = t.parse().iterator().next();

            ((JavacTaskImpl)t).enter();

            for (int r = 0; r < 2; r++) {
                List<String> actual = new ArrayList<>();

                new TreePathScanner<Void, Void>() {
                    @Override
                    public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
                        Scope scope = Trees.instance(t).getScope(new TreePath(getCurrentPath(), node.getBody()));
                        actual.addAll(dumpScope(scope));
                        return super.visitLambdaExpression(node, p);
                    }
                }.scan(cut, null);

                List<String> expectedList = List.of(expected);

                if (!expectedList.equals(actual)) {
                    throw new IllegalStateException("Unexpected scope content: " + actual + "\n" +
                                                     "expected: " + expectedList);
                }

                t.analyze();
            }
        }
    }

    void testAnalyzerDisabled() throws IOException {
        JavacTool c = JavacTool.create();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            class MyFileObject extends SimpleJavaFileObject {
                MyFileObject() {
                    super(URI.create("myfo:///Test.java"), SOURCE);
                }
                @Override
                public String getCharContent(boolean ignoreEncodingErrors) {
                    return "class Test {" +
                           "    void test() { cand(() -> { System.err.println(); }); }" +
                           "    Runnable r = new Runnable() { public void test() { System.err.println(); } };" +
                           "    void cand(Runnable r) { }" +
                           "}";
                }
            }
            Context ctx = new Context();
            TestAnalyzer.preRegister(ctx);
            JavacTask t = (JavacTask) c.getTask(null, fm, null, List.of("-XDfind=lambda"), null,
                                                List.of(new MyFileObject()), ctx);
            CompilationUnitTree cut = t.parse().iterator().next();
            t.analyze();

            TestAnalyzer analyzer = (TestAnalyzer) TestAnalyzer.instance(ctx);

            if (!analyzer.analyzeCalled) {
                throw new IllegalStateException("Analyzer didn't run!");
            }

            new TreePathScanner<Void, Void>() {
                @Override
                public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
                    analyzer.analyzeCalled = false;
                    Trees.instance(t).getScope(new TreePath(getCurrentPath(), node.getBody()));
                    if (analyzer.analyzeCalled) {
                        throw new IllegalStateException("Analyzer was run during getScope!");
                    }
                    return super.visitLambdaExpression(node, p);
                }

                @Override
                public Void visitVariable(VariableTree node, Void p) {
                    if (node.getInitializer() != null) {
                        analyzer.analyzeCalled = false;
                        TreePath tp = new TreePath(getCurrentPath(), node.getInitializer());
                        Trees.instance(t).getScope(tp);
                        if (analyzer.analyzeCalled) {
                            throw new IllegalStateException("Analyzer was run during getScope!");
                        }
                    }
                    return super.visitVariable(node, p);
                }
            }.scan(cut, null);
        }
    }

    private static final class TestAnalyzer extends Analyzer {

        public static void preRegister(Context context) {
            context.put(analyzerKey, (Factory<Analyzer>) ctx -> new TestAnalyzer(ctx));
        }

        private boolean analyzeCalled;

        public TestAnalyzer(Context context) {
            super(context);
        }

        @Override
        protected void analyze(JCStatement statement, Env<AttrContext> env) {
            analyzeCalled = true;
            super.analyze(statement, env);
        }
    }

    void testVariablesInSwitch() throws IOException {
        JavacTool c = JavacTool.create();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            class MyFileObject extends SimpleJavaFileObject {
                MyFileObject() {
                    super(URI.create("myfo:///Test.java"), SOURCE);
                }
                @Override
                public String getCharContent(boolean ignoreEncodingErrors) {
                    return "class Test {" +
                           "    void test() {\n" +
                           "        E e = E.A;\n" +
                           "        Object o = E.A;\n" +
                           "        switch (e) {\n" +
                           "            case A:\n" +
                           "                return;\n" +
                           "            case B:\n" +
                           "                test();\n" +
                           "                E ee = null;\n" +
                           "                break;\n" +
                           "        }\n" +
                           "    }\n" +
                           "    enum E {A, B}\n" +
                           "}";
                }
            }
            Context ctx = new Context();
            TestAnalyzer.preRegister(ctx);
            JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null,
                                                List.of(new MyFileObject()), ctx);
            CompilationUnitTree cut = t.parse().iterator().next();
            t.analyze();

            new TreePathScanner<Void, Void>() {
                @Override
                public Void visitMethodInvocation(MethodInvocationTree node, Void p) {
                    Trees.instance(t).getScope(getCurrentPath());
                    return super.visitMethodInvocation(node, p);
                }
            }.scan(cut, null);
        }
    }

    void testMemberRefs() throws IOException {
        JavacTool c = JavacTool.create();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            class MyFileObject extends SimpleJavaFileObject {
                MyFileObject() {
                    super(URI.create("myfo:///Test.java"), SOURCE);
                }
                @Override
                public String getCharContent(boolean ignoreEncodingErrors) {
                    return "class Test {" +
                           "    void test() {\n" +
                           "        Test t = this;\n" +
                           "        Runnable r1 = t::test;\n" +
                           "        Runnable r2 = true ? t::test : t::test;\n" +
                           "        c(t::test);\n" +
                           "        c(true ? t::test : t::test);\n" +
                           "    }\n" +
                           "    void c(Runnable r) {}\n" +
                           "}";
                }
            }
            Context ctx = new Context();
            TestAnalyzer.preRegister(ctx);
            JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null,
                                                List.of(new MyFileObject()), ctx);
            CompilationUnitTree cut = t.parse().iterator().next();
            t.analyze();

            new TreePathScanner<Void, Void>() {
                @Override
                public Void visitConditionalExpression(ConditionalExpressionTree node, Void p) {
                    Trees.instance(t).getScope(new TreePath(getCurrentPath(), node.getCondition()));
                    return super.visitConditionalExpression(node, p);
                }

                @Override
                public Void visitBlock(BlockTree node, Void p) {
                    Trees.instance(t).getScope(getCurrentPath());
                    return super.visitBlock(node, p);
                }
            }.scan(cut, null);
        }
    }

    void testAnnotations() throws IOException {
        JavacTool c = JavacTool.create();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            class MyFileObject extends SimpleJavaFileObject {
                MyFileObject() {
                    super(URI.create("myfo:///Test.java"), SOURCE);
                }
                @Override
                public String getCharContent(boolean ignoreEncodingErrors) {
                    return "class Test {" +
                           "    void test() {\n" +
                           "        new Object() {\n" +
                           "            @A\n" +
                           "            public String t() { return null; }\n" +
                           "        };\n" +
                           "    }\n" +
                           "    @interface A {}\n" +
                           "}";
                }
            }
            Context ctx = new Context();
            TestAnalyzer.preRegister(ctx);
            JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null,
                                                List.of(new MyFileObject()), ctx);
            CompilationUnitTree cut = t.parse().iterator().next();
            t.analyze();

            new TreePathScanner<Void, Void>() {
                @Override
                public Void visitIdentifier(IdentifierTree node, Void p) {
                    if (node.getName().contentEquals("A")) {
                        Trees.instance(t).getScope(getCurrentPath());
                    }
                    return super.visitIdentifier(node, p);
                }

                @Override
                public Void visitMethod(MethodTree node, Void p) {
                    super.visitMethod(node, p);
                    if (node.getReturnType() != null) {
                        Trees.instance(t).getScope(new TreePath(getCurrentPath(), node.getReturnType()));
                    }
                    return null;
                }
            }.scan(cut, null);
        }
    }

    void testAnnotationsLazy() throws IOException {
        JavacTool c = JavacTool.create();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            class MyFileObject extends SimpleJavaFileObject {
                MyFileObject() {
                    super(URI.create("myfo:///Test.java"), SOURCE);
                }
                @Override
                public String getCharContent(boolean ignoreEncodingErrors) {
                    return "import java.lang.annotation.*;\n" +
                           "\n" +
                           "class ClassA {\n" +
                           "    Object o = ClassB.lcv;\n" +
                           "}\n" +
                           "\n" +
                           "class ClassB {\n" +
                           "    static final String[] lcv = new @TA String[0];\n" +
                           "}\n" +
                           "\n" +
                           "class ClassC {\n" +
                           "    static final Object o = (@TA Object) null;\n" +
                           "}\n" +
                           "\n" +
                           "@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})\n" +
                           "@interface TA {}\n";
                }
            }
            Context ctx = new Context();
            TestAnalyzer.preRegister(ctx);
            JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null,
                                                List.of(new MyFileObject()), ctx);
            t.addTaskListener(new TaskListener() {
                @Override
                public void finished(TaskEvent e) {
                    if (e.getKind() == TaskEvent.Kind.ANALYZE) {
                        new TreePathScanner<Void, Void>() {
                            @Override
                            public Void scan(Tree tree, Void p) {
                                if (tree != null) {
                                    Trees.instance(t).getScope(new TreePath(getCurrentPath(), tree));
                                }
                                return super.scan(tree, p);
                            }
                        }.scan(Trees.instance(t).getPath(e.getTypeElement()), null);
                    }
                }
            });

            t.call();
        }
    }

    void testCircular() throws IOException {
        JavacTool c = JavacTool.create();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            class MyFileObject extends SimpleJavaFileObject {
                MyFileObject() {
                    super(URI.create("myfo:///Test.java"), SOURCE);
                }
                @Override
                public String getCharContent(boolean ignoreEncodingErrors) {
                    return "class Test extends Test {" +
                           "    {\n" +
                           "        int i;\n" +
                           "    }\n" +
                           "}";
                }
            }
            Context ctx = new Context();
            TestAnalyzer.preRegister(ctx);
            JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null,
                                                List.of(new MyFileObject()), ctx);
            CompilationUnitTree cut = t.parse().iterator().next();
            t.analyze();

            new TreePathScanner<Void, Void>() {
                @Override
                public Void visitBlock(BlockTree node, Void p) {
                    Trees.instance(t).getScope(getCurrentPath());
                    return super.visitBlock(node, p);
                }
            }.scan(cut, null);
        }
    }

    void testRecord() throws IOException {
        JavacTool c = JavacTool.create();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            class MyFileObject extends SimpleJavaFileObject {
                MyFileObject() {
                    super(URI.create("myfo:///Test.java"), SOURCE);
                }
                @Override
                public String getCharContent(boolean ignoreEncodingErrors) {
                    return "record Test<T>(int mark) {}";
                }
            }
            Context ctx = new Context();
            TestAnalyzer.preRegister(ctx);
            JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null,
                                                List.of(new MyFileObject()), ctx);
            CompilationUnitTree cut = t.parse().iterator().next();
            t.analyze();

            List<String> actual = new ArrayList<>();

            new TreePathScanner<Void, Void>() {
                @Override
                public Void visitClass(ClassTree node, Void p) {
                    Scope scope = Trees.instance(t).getScope(getCurrentPath());
                    actual.addAll(dumpScope(scope));
                    return super.visitClass(node, p);
                }
            }.scan(cut, null);

            List<String> expected = List.of(
                    "super:java.lang.Record",
                    "this:Test<T>",
                    "T:T"
            );

            if (!expected.equals(actual)) {
                throw new AssertionError("Unexpected Scope content: " + actual);
            }
        }
    }

    void testLocalRecordAnnotation() throws IOException {
        JavacTool c = JavacTool.create();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            class Variant {
                final String code;
                final List<List<String>> expectedScopeContent;
                public Variant(String code, List<List<String>> expectedScopeContent) {
                    this.code = code;
                    this.expectedScopeContent = expectedScopeContent;
                }
            }
            Variant[] variants = new Variant[] {
                new Variant("""
                            class Test {
                                void t() {
                                    record R(@Annotation int i) {
                                        void stop () {}
                                    }
                                }
                            }
                            @interface Annotation {}
                            """,
                            List.of(
                                List.of("super:java.lang.Object", "this:Test"),
                                List.of("super:java.lang.Object", "this:Test")
                            )),
                new Variant("""
                            record Test(@Annotation int i) {}
                            @interface Annotation {}
                            """,
                            List.of(
                                List.of("i:int", "super:java.lang.Record", "this:Test"),
                                List.of("super:java.lang.Record", "this:Test")
                            ))
            };
            for (Variant currentVariant : variants) {
                class MyFileObject extends SimpleJavaFileObject {
                    MyFileObject() {
                        super(URI.create("myfo:///Test.java"), SOURCE);
                    }
                    @Override
                    public String getCharContent(boolean ignoreEncodingErrors) {
                        return currentVariant.code;
                    }
                }
                Context ctx = new Context();
                TestAnalyzer.preRegister(ctx);
                JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null,
                                                    List.of(new MyFileObject()), ctx);
                CompilationUnitTree cut = t.parse().iterator().next();
                t.analyze();

                List<List<String>> actual = new ArrayList<>();

                new TreePathScanner<Void, Void>() {
                    @Override
                    public Void visitAnnotation(AnnotationTree node, Void p) {
                        Scope scope = Trees.instance(t).getScope(getCurrentPath());
                        actual.add(dumpScope(scope));
                        return super.visitAnnotation(node, p);
                    }
                }.scan(cut, null);

                if (!currentVariant.expectedScopeContent.equals(actual)) {
                    throw new AssertionError("Unexpected Scope content: " + actual);
                }
            }
        }
    }

    void testRuleCases() throws IOException {
        JavacTool c = JavacTool.create();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            String code = """
                          class Test {
                              void t(int i) {
                                  long local;
                                  System.err.println(switch (i) {
                                    case 0 -> {
                                        String var;
                                        int scopeHere;
                                        yield "";
                                    }
                                    default -> {
                                        String var;
                                        int scopeHere;
                                        yield "";
                                    }
                                  });
                                  switch (i) {
                                    case 0 -> {
                                        String var;
                                        int scopeHere;
                                    }
                                    default -> {
                                        String var;
                                        int scopeHere;
                                    }
                                  };
                                  switch (i) {
                                    case 0: {
                                        int checkTree;
                                    }
                                  }
                              }
                          }
                          """;
            class MyFileObject extends SimpleJavaFileObject {
                MyFileObject() {
                    super(URI.create("myfo:///Test.java"), SOURCE);
                }
                @Override
                public String getCharContent(boolean ignoreEncodingErrors) {
                    return code;
                }
            }
            Context ctx = new Context();
            TestAnalyzer.preRegister(ctx);
            JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null,
                                                List.of(new MyFileObject()), ctx);
            CompilationUnitTree cut = t.parse().iterator().next();
            t.analyze();

            List<List<String>> actual = new ArrayList<>();

            new TreePathScanner<Void, Void>() {
                @Override
                public Void visitVariable(VariableTree node, Void p) {
                    if (node.getName().contentEquals("scopeHere")) {
                        Scope scope = Trees.instance(t).getScope(getCurrentPath());
                        actual.add(dumpScope(scope));
                        JCTree body = getCaseBody(scope);
                        if (body == null) {
                            throw new AssertionError("Unexpected null body.");
                        }
                    } else if (node.getName().contentEquals("checkTree")) {
                        Scope scope = Trees.instance(t).getScope(getCurrentPath());
                        JCTree body = getCaseBody(scope);
                        if (body != null) {
                            throw new AssertionError("Unexpected body tree: " + body);
                        }
                    }
                    return super.visitVariable(node, p);
                }
                JCTree getCaseBody(Scope scope) {
                    return ((JCCase) ((JavacScope) scope).getEnv().next.next.tree).body;
                }
            }.scan(cut, null);

            List<List<String>> expected =
                    Collections.nCopies(4,
                                        List.of("scopeHere:int",
                                                "var:java.lang.String",
                                                "local:long",
                                                "i:int",
                                                "super:java.lang.Object",
                                                "this:Test"
                                            ));

            if (!expected.equals(actual)) {
                throw new AssertionError("Unexpected Scope content: " + actual);
            }
        }
    }

    void testNestedSwitchExpression() throws IOException {
        JavacTool c = JavacTool.create();
        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
            String code = """
                          class Test {
                              void t(Object o1, Object o2) {
                                  System.err.println(switch (o1) {
                                    case String s -> switch (j) {
                                        case Integer i -> {
                                            int scopeHere;
                                            yield "";
                                        }
                                        default -> "";
                                    };
                                    default -> "";
                                  });
                              }
                          }
                          """;
            class MyFileObject extends SimpleJavaFileObject {
                MyFileObject() {
                    super(URI.create("myfo:///Test.java"), SOURCE);
                }
                @Override
                public String getCharContent(boolean ignoreEncodingErrors) {
                    return code;
                }
            }
            Context ctx = new Context();
            TestAnalyzer.preRegister(ctx);
            JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null,
                                                List.of(new MyFileObject()), ctx);
            CompilationUnitTree cut = t.parse().iterator().next();
            t.analyze();

            List<List<String>> actual = new ArrayList<>();

            new TreePathScanner<Void, Void>() {
                @Override
                public Void visitVariable(VariableTree node, Void p) {
                    if (node.getName().contentEquals("scopeHere")) {
                        Scope scope = Trees.instance(t).getScope(getCurrentPath());
                        actual.add(dumpScope(scope));
                        JCTree body = getCaseBody(scope);
                        if (body == null) {
                            throw new AssertionError("Unexpected null body.");
                        }
                    }
                    return super.visitVariable(node, p);
                }
                JCTree getCaseBody(Scope scope) {
                    return ((JCCase) ((JavacScope) scope).getEnv().next.next.tree).body;
                }
            }.scan(cut, null);

            List<List<String>> expected =
                    List.of(List.of("scopeHere:int",
                                    "i:java.lang.Integer",
                                    "s:java.lang.String",
                                    "o2:java.lang.Object",
                                    "o1:java.lang.Object",
                                    "super:java.lang.Object",
                                    "this:Test"
                                ));

            if (!expected.equals(actual)) {
                throw new AssertionError("Unexpected Scope content: " + actual);
            }
        }
    }

    private List<String> dumpScope(Scope scope) {
        List<String> content = new ArrayList<>();
        while (scope.getEnclosingClass() != null) {
            for (Element el : scope.getLocalElements()) {
                content.add(el.getSimpleName() + ":" +el.asType().toString());
            }
            scope = scope.getEnclosingScope();
        }
        return content;
    }
}