GROOVY-12242: instanceof pattern variable scope is not aligned with Java flow scoping (JEP 394)

src/main/java/org/codehaus/groovy/ast/expr/DeclarationExpression.java

@@ -43,6 +43,12 @@
  * you can use the method "<code>TupleExpression getTupleExpression()</code>" method.
  * Calling either of these expression getters when the "isMultipleAssignment" condition
  * is not appropriate is unsafe and will result in a <code>ClassCastException</code>.
+ * <p>
+ * JEP&nbsp;394 type patterns reuse this node as the right-hand side of
+ * {@code instanceof}: {@code e instanceof String s} is modelled as an
+ * {@code instanceof} {@link BinaryExpression} whose RHS is a
+ * {@code DeclarationExpression} with an {@link EmptyExpression} initializer.
+ * The pattern variable's scope is flow-sensitive (see GROOVY-12242).
  */
 public class DeclarationExpression extends BinaryExpression {
 
@@ -130,6 +136,11 @@ public TupleExpression getTupleExpression() {
                     : null;
     }
 
+    /**
+     * Returns the type of the declared variable (or of the tuple for a multiple
+     * assignment). For a JEP&nbsp;394 pattern used as the RHS of {@code instanceof},
+     * this is the pattern type {@code T} in {@code e instanceof T t}.
+     */
     @Override
     public ClassNode getType() {
         return (isMultipleAssignmentDeclaration() ? getTupleExpression() : getVariableExpression()).getType();

src/main/java/org/codehaus/groovy/classgen/AsmClassGenerator.java

@@ -27,6 +27,7 @@
 import org.codehaus.groovy.ast.ClassHelper;
 import org.codehaus.groovy.ast.ClassNode;
 import org.codehaus.groovy.ast.ConstructorNode;
+import org.codehaus.groovy.ast.DynamicVariable;
 import org.codehaus.groovy.ast.FieldNode;
 import org.codehaus.groovy.ast.GenericsType;
 import org.codehaus.groovy.ast.InnerClassNode;
@@ -1648,7 +1649,7 @@
      * {@inheritDoc}
      */
     @Override
     public void visitVariableExpression(final VariableExpression expression) {
         CompileStack compileStack = controller.getCompileStack();
 
         if (expression.isThisExpression()) {
@@ -1673,14 +1674,27 @@
             return;
         }
 
-        BytecodeVariable variable = compileStack.getVariable(expression.getName(), /*throwIfMissing*/false);
-        if (variable != null) {
-            controller.getOperandStack().loadOrStoreVariable(variable, expression.isUseReferenceDirectly());
-        } else {
+        // GROOVY-12242: VariableScopeVisitor marks out-of-scope pattern references
+        // as DynamicVariable. Name-based CompileStack lookup must not bypass that:
+        // pattern slots are allocated during condition evaluation and can still be
+        // present on the stack for short-circuit RHS of || (where the pattern is
+        // not definitely bound) or briefly on a non-live arm before hide. Treat
+        // DynamicVariable as property access even when a same-named slot exists.
+        if (expression.getAccessedVariable() instanceof DynamicVariable) {
             PropertyExpression pexp = thisPropX(/*implicit-this*/true, expression.getName());
             pexp.getProperty().setSourcePosition(expression);
             pexp.copyNodeMetaData(expression);
             pexp.visit(this);
+        } else {
+            BytecodeVariable variable = compileStack.getVariable(expression.getName(), /*throwIfMissing*/false);
+            if (variable != null) {
+                controller.getOperandStack().loadOrStoreVariable(variable, expression.isUseReferenceDirectly());
+            } else {
+                PropertyExpression pexp = thisPropX(/*implicit-this*/true, expression.getName());
+                pexp.getProperty().setSourcePosition(expression);
+                pexp.copyNodeMetaData(expression);
+                pexp.visit(this);
+            }
         }
 
         if (!compileStack.isLHS()) {