Issue #2388: Fixed translation of Java 16+ pattern matching in instanceof expressions within if statements.

This change introduces a `needsCastChk` flag to `CastExpression` to prevent redundant runtime cast checks. When translating `if (expr instanceof Type var)`, a local variable `var` is declared and initialized with a cast of `expr`. Since the `instanceof` check already guarantees type safety, the generated cast does not need an additional runtime check. For complex conditions like `if (expr instanceof Type var && otherCondition)`, the translation now creates a nested `if` statement for `otherCondition` inside the block where `var` is in scope.

PiperOrigin-RevId: 812930294

Author: tomball

translator/src/main/java/com/google/devtools/j2objc/ast/CastExpression.java

@@ -23,11 +23,13 @@ public class CastExpression extends Expression {
 
   private ChildLink<Type> type = ChildLink.create(Type.class, this);
   private ChildLink<Expression> expression = ChildLink.create(Expression.class, this);
+  private boolean needsCastChk = true;
 
   public CastExpression(CastExpression other) {
     super(other);
     type.copyFrom(other.getType());
     expression.copyFrom(other.getExpression());
+    needsCastChk = other.needsCastChk;
   }
 
   public CastExpression(TypeMirror typeMirror, Expression expression) {
@@ -66,6 +68,14 @@ public CastExpression setExpression(Expression newExpression) {
     return this;
   }
 
+  public boolean needsCastChk() {
+    return needsCastChk;
+  }
+
+  public void setNeedsCastChk(boolean value) {
+    needsCastChk = value;
+  }
+
   @Override
   protected void acceptInner(TreeVisitor visitor) {
     if (visitor.visit(this)) {

translator/src/main/java/com/google/devtools/j2objc/javac/TreeConverter.java

@@ -1013,36 +1013,83 @@ private TreeNode convertIdent(IdentifierTree node, TreePath parent) {
   private TreeNode convertIf(IfTree node, TreePath parent) {
     TreePath path = getTreePath(parent, node);
     Expression condition = convertWithoutParens(node.getCondition(), path);
-    Statement thenStatement = (Statement) convert(node.getThenStatement(), path);
-    Statement newNode = new IfStatement()
-        .setExpression(condition)
-        .setThenStatement(thenStatement)
-        .setElseStatement((Statement) convert(node.getElseStatement(), path));
+    Pattern pattern = null;
     InstanceofExpression instanceofExpr = null;
+    Expression subExpr = null;
     if (condition.getKind() == TreeNode.Kind.INSTANCEOF_EXPRESSION) {
       instanceofExpr = (InstanceofExpression) condition;
+      pattern = instanceofExpr.getPattern();
+      instanceofExpr.setPattern(null);
     } else if (condition.getKind() == TreeNode.Kind.INFIX_EXPRESSION) {
-      for (Expression operand : ((InfixExpression) condition).getOperands()) {
+      InfixExpression infixExpr = (InfixExpression) condition;
+      List<Expression> operands = infixExpr.getOperands();
+      for (int i = 0; i < operands.size(); i++) {
+        Expression operand = operands.get(i);
         if (operand.getKind() == TreeNode.Kind.INSTANCEOF_EXPRESSION) {
           instanceofExpr = (InstanceofExpression) operand;
-          break;
+          pattern = instanceofExpr.getPattern();
+          if (pattern != null) {
+            instanceofExpr.setPattern(null);
+            condition = instanceofExpr.copy();
+            List<Expression> subOperands = new ArrayList<>();
+            while (++i < operands.size()) {
+              subOperands.add(operands.get(i));
+            }
+            if (subOperands.size() == 1) {
+              subExpr = subOperands.get(0).copy();
+            } else if (subOperands.size() > 1) {
+              InfixExpression newInfix =
+                  new InfixExpression(infixExpr.getTypeMirror(), infixExpr.getOperator());
+              for (Expression subOperand : subOperands) {
+                newInfix.addOperand(subOperand.copy());
+              }
+              subExpr = newInfix;
+            }
+            break;
+          } else {
+            // No pattern, reset instanceofExpr and pattern.
+            instanceofExpr = null;
+            pattern = null;
+          }
         }
       }
     }
-    Pattern pattern = instanceofExpr != null ? instanceofExpr.getPattern() : null;
+
+    Statement thenStatement = (Statement) convert(node.getThenStatement(), path);
     if (pattern != null) {
       // Create local variable with pattern variable element.
       VariableElement localVar =
           ((Pattern.BindingPattern) pattern).getVariable().getVariableElement();
-      CastExpression castExpr = new CastExpression(localVar.asType(),
-          instanceofExpr.getLeftOperand().copy());
+      CastExpression castExpr =
+          new CastExpression(localVar.asType(), instanceofExpr.getLeftOperand().copy());
+      castExpr.setNeedsCastChk(false);
       VariableDeclarationStatement localVarDecl =
           new VariableDeclarationStatement(localVar, castExpr);
-      Block block = new Block()
-          .addStatement(localVarDecl)
-          .addStatement(newNode);
-      newNode = block;
+      Block thenBlock;
+      if (thenStatement.getKind() == TreeNode.Kind.BLOCK) {
+        thenBlock = (Block) thenStatement;
+      } else {
+        thenBlock = new Block();
+        thenBlock.addStatement(thenStatement);
+      }
+      thenBlock.addStatement(0, localVarDecl);
+      if (subExpr != null) {
+        // Move statements inside of if statement with subExpr condition.
+        IfStatement subIf = new IfStatement().setExpression(subExpr);
+        Block subIfBlock = new Block();
+        subIf.setThenStatement(subIfBlock);
+        while (thenBlock.getStatements().size() > 1) {
+          subIfBlock.addStatement(thenBlock.getStatements().remove(1));
+        }
+        thenBlock.addStatement(subIf);
+      }
+      thenStatement = thenBlock;
     }
+    Statement newNode =
+        new IfStatement()
+            .setExpression(condition)
+            .setThenStatement(thenStatement)
+            .setElseStatement((Statement) convert(node.getElseStatement(), path));
     return newNode;
   }
 
@@ -1201,6 +1248,7 @@ private void maybeAddUnreachableDirective(Block body) {
     }
   }
 
+  @SuppressWarnings("StatementSwitchToExpressionSwitch")
   private static String getMemberName(ExpressionTree node) {
     switch (node.getKind().name()) {
       case "IDENTIFIER":
@@ -1883,6 +1931,7 @@ private TreeNode getAssociatedJavaDoc(Tree node, TreePath path) {
     return comment != null && comment.isDocComment() ? comment : null;
   }
 
+  @SuppressWarnings("StatementSwitchToExpressionSwitch")
   private Comment convertAssociatedComment(Tree node, TreePath path) {
     boolean docCommentsEnabled = newUnit.getEnv().options().docCommentsEnabled();
     DocCommentTable docComments = ((JCCompilationUnit) unit).docComments;

translator/src/main/java/com/google/devtools/j2objc/translate/CastResolver.java

@@ -111,9 +111,11 @@ public void endVisit(CastExpression node) {
         return;
       }
 
-      FunctionInvocation castCheck = createCastCheck(type, expr);
-      if (castCheck != null) {
-        node.setExpression(castCheck);
+      if (node.needsCastChk()) {
+        FunctionInvocation castCheck = createCastCheck(type, expr);
+        if (castCheck != null) {
+          node.setExpression(castCheck);
+        }
       }
     }
   }