8267610: NPE at at jdk.compiler/com.sun.tools.javac.jvm.Code.emitop

8268748: Javac generates uncorrect bytecodes when using nested pattern variables

Reviewed-by: jlahoda, vromero

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

@@ -186,12 +186,14 @@ public class TransPatterns extends TreeTranslator {
             //=>
             //(let T' N$temp = E; N$temp instanceof typeof($pattern) && <desugared $pattern>)
             //note the pattern desugaring performs binding variable assignments
-            Symbol exprSym = TreeInfo.symbol(tree.expr);
             Type tempType = tree.expr.type.hasTag(BOT) ?
                     syms.objectType
                     : tree.expr.type;
             VarSymbol prevCurrentValue = currentValue;
             try {
+                JCExpression translatedExpr = translate(tree.expr);
+                Symbol exprSym = TreeInfo.symbol(translatedExpr);
+
                 if (exprSym != null &&
                     exprSym.kind == Kind.VAR &&
                     exprSym.owner.kind.matches(Kinds.KindSelector.VAL_MTH)) {
@@ -203,7 +205,6 @@ public class TransPatterns extends TreeTranslator {
                             currentMethodSym);
                 }
 
-                JCExpression translatedExpr = translate(tree.expr);
                 Type principalType = principalType((JCPattern) tree.pattern);
                 result = makeBinary(Tag.AND,
                                     makeTypeTest(make.Ident(currentValue), make.Type(principalType)),

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 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 8267610
+ * @summary LambdaToMethod cannot capture pattern variables. So the TransPatterns should
+ *          transform the pattern variables and symbols to normal variables and symbols.
+ * @compile --enable-preview -source ${jdk.version} LambdaCannotCapturePatternVariables.java
+ * @run main/othervm --enable-preview LambdaCannotCapturePatternVariables
+ */
+
+import java.util.function.Supplier;
+
+public class LambdaCannotCapturePatternVariables {
+
+    public static void main(String[] args) {
+        var testVar = new LambdaCannotCapturePatternVariables();
+        testVar.testInstanceOfPatternVariable(Integer.valueOf(1));
+        testVar.testSwitchPatternVariable(Integer.valueOf(1));
+        testVar.test(Integer.valueOf(1));
+    }
+
+    public Integer testInstanceOfPatternVariable(Object x) {
+        if(x instanceof Number y) {
+            return ((Supplier<Integer>) (() -> {
+                return ((y instanceof Integer z) ? z : 1);
+            })).get();
+        }
+        return null;
+    }
+
+    public Integer testSwitchPatternVariable(Object x) {
+        switch (x) {
+            case Number n: {
+                return ((Supplier<Integer>) (() -> {
+                    return ((n instanceof Integer i) ? i : 1);
+                })).get();
+            }
+            default: return null;
+        }
+    }
+
+    // Provided by the user
+    public Integer test(Object x) {
+        Integer bar = 1;
+        return ((x instanceof Number y) ?
+                ((Supplier<Integer>) (() -> {
+                    return ((y instanceof Integer z) ? z : bar);
+                })).get() : bar);
+    }
+}

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

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 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 8268748
+ * @summary Javac generates error opcodes when using nest pattern variables
+ * @library /tools/lib
+ * @modules jdk.compiler/com.sun.tools.javac.api
+ *          jdk.compiler/com.sun.tools.javac.main
+ *          jdk.jdeps/com.sun.tools.classfile
+ * @build toolbox.ToolBox toolbox.JavacTask
+ * @run main NestedPatternVariablesBytecode
+ */
+
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.StreamSupport;
+
+import com.sun.tools.classfile.ClassFile;
+import com.sun.tools.classfile.ConstantPoolException;
+import com.sun.tools.classfile.Method;
+import com.sun.tools.classfile.Attribute;
+import com.sun.tools.classfile.Code_attribute;
+import com.sun.tools.classfile.Instruction;
+
+import toolbox.JavacTask;
+import toolbox.TestRunner;
+import toolbox.ToolBox;
+
+public class NestedPatternVariablesBytecode extends TestRunner {
+    private static final String JAVA_VERSION = System.getProperty("java.specification.version");
+    private static final String TEST_METHOD = "test";
+
+    ToolBox tb;
+    ClassFile cf;
+
+    public NestedPatternVariablesBytecode() {
+        super(System.err);
+        tb = new ToolBox();
+    }
+
+    public static void main(String[] args) throws Exception {
+        NestedPatternVariablesBytecode t = new NestedPatternVariablesBytecode();
+        t.runTests();
+    }
+
+    @Test
+    public void testNestedPatternVariablesBytecode() throws Exception {
+        String code = """
+                class NestedPatterVariablesTest {
+                    String test(Object o) {
+                        if (o instanceof (CharSequence cs && cs instanceof String s)) {
+                            return s;
+                        }
+                        return null;
+                    }
+                }""";
+        Path curPath = Path.of(".");
+        new JavacTask(tb)
+                .options("--enable-preview", "-source", JAVA_VERSION)
+                .sources(code)
+                .outdir(curPath)
+                .run();
+
+        cf = ClassFile.read(curPath.resolve("NestedPatterVariablesTest.class"));
+        Method testMethod = Arrays.stream(cf.methods)
+                                  .filter(m -> isTestMethod(m))
+                                  .findAny()
+                                  .get();
+        Code_attribute code_attribute = (Code_attribute) testMethod.attributes.get(Attribute.Code);
+
+        List<String> actualCode = getCodeInstructions(code_attribute);
+        List<String> expectedCode = Arrays.asList(
+                "aload_1", "instanceof", "ifeq", "aload_1", "checkcast", "astore_2", "aload_2", "instanceof",
+                "ifeq", "aload_2", "checkcast", "astore_3", "aload_3", "areturn", "aconst_null", "areturn");
+        tb.checkEqual(expectedCode, actualCode);
+    }
+
+    boolean isTestMethod(Method m) {
+        try {
+            return TEST_METHOD.equals(m.getName(cf.constant_pool));
+        } catch (ConstantPoolException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    List<String> getCodeInstructions(Code_attribute code) {
+        return StreamSupport.stream(code.getInstructions().spliterator(), false)
+                .map(Instruction::getMnemonic)
+                .toList();
+    }
+}