[swiftsrc2cpg] De-sugar tuple patterns in if-case/guard-case conditions (#5920)

Extend tuple pattern de-sugaring from switch-case to if-case and
guard-case conditions. Rename existing switch-specific helpers to
context-agnostic names and promote them to protected visibility for
reuse across AST creator traits.

Supported patterns:
- if case (1, 2) = expr (expression tuple, equality chain)
- if case let (a, b) = expr (binding tuple, field access assignments)
- if case (let a, 1) = expr (mixed binding + equality)
- guard case let (a, b) = expr (bindings under enclosing scope)
- if case let ((a, b), c) = expr (nested tuples)
- if let (a, b) = optionalExpr (optional binding with tuple)
- isTupleN condition check as the final expression in tuple
condition blocks so that the condition has an explicit boolean test

Author: max-leuthaeuser

joern-cli/frontends/swiftsrc2cpg/src/main/scala/io/joern/swiftsrc2cpg/astcreation/AstForExprSyntaxCreator.scala

@@ -722,7 +722,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
     * identifier/field-identifier nodes so the resulting AST can be safely used as an argument without node-sharing
     * issues.
     */
-  private def createFieldAccessChain(baseName: String, fields: List[String], node: SwiftNode): Ast = {
+  protected def createFieldAccessChain(baseName: String, fields: List[String], node: SwiftNode): Ast = {
     val baseAst = Ast(identifierNode(node, baseName))
     fields.foldLeft(baseAst) { (accAst, field) =>
       createFieldAccessCallAst(node, accAst, fieldIdentifierNode(node, field, field))
@@ -740,7 +740,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
     * Nested tuples like case ((1, 2), 3): are handled recursively: <subject>.0.0 == 1 && <subject>.0.1 == 2 &&
     * <subject>.1 == 3
     */
-  private def astForExpressionTuplePatternInSwitchContext(
+  protected def astForExpressionTuplePattern(
     tupleExpr: TupleExprSyntax,
     subjectBase: String,
     subjectFieldPath: List[String],
@@ -753,7 +753,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
       val subjectAst  = createFieldAccessChain(subjectBase, currentPath, node)
       element.expression match {
         case inner: TupleExprSyntax =>
-          astForExpressionTuplePatternInSwitchContext(inner, subjectBase, currentPath, node)
+          astForExpressionTuplePattern(inner, subjectBase, currentPath, node)
         case _ =>
           val rhsAst = astForNode(element)
           val eqCode = s"$subjectCode == ${code(element.expression)}"
@@ -768,7 +768,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
     }
   }
 
-  private def isBindingTupleExpr(tupleExpr: TupleExprSyntax): Boolean = {
+  protected def isBindingTupleExpr(tupleExpr: TupleExprSyntax): Boolean = {
     tupleExpr.elements.children.exists { elem =>
       elem.expression.isInstanceOf[PatternExprSyntax]
     }
@@ -782,16 +782,16 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
           case ep: ExpressionPatternSyntax if ep.expression.isInstanceOf[TupleExprSyntax] =>
             val tupleExpr = ep.expression.asInstanceOf[TupleExprSyntax]
             if (isBindingTupleExpr(tupleExpr)) {
-              astsForBindingTupleExprInSwitchContext(tupleExpr, tmpName, List.empty, ep)
+              astsForBindingTupleExpr(tupleExpr, tmpName, List.empty, ep)
             } else {
-              List(astForExpressionTuplePatternInSwitchContext(tupleExpr, tmpName, List.empty, ep))
+              List(astForExpressionTuplePattern(tupleExpr, tmpName, List.empty, ep))
             }
           case vb: ValueBindingPatternSyntax =>
             vb.pattern match {
               case tp: TuplePatternSyntax =>
-                astsForBindingTuplePatternInSwitchContext(tp, tmpName, List.empty, vb)
+                astsForBindingTuplePattern(tp, tmpName, List.empty, vb)
               case ep: ExpressionPatternSyntax if ep.expression.isInstanceOf[TupleExprSyntax] =>
-                astsForBindingTupleExprInSwitchContext(
+                astsForBindingTupleExpr(
                   ep.expression.asInstanceOf[TupleExprSyntax],
                   tmpName,
                   List.empty,
@@ -801,7 +801,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
               case _ => List(astForNode(item.pattern))
             }
           case tuple: TuplePatternSyntax =>
-            astsForBindingTuplePatternInSwitchContext(tuple, tmpName, List.empty, tuple)
+            astsForBindingTuplePattern(tuple, tmpName, List.empty, tuple)
           case _ =>
             List(astForNode(item.pattern))
         }
@@ -825,7 +825,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
     */
 
   /** Creates an instanceOf check for an IsTypePatternSyntax against a subject field access. */
-  private def astForIsTypePatternInTupleContext(
+  protected def astForIsTypePatternInTupleContext(
     isType: IsTypePatternSyntax,
     subjectAst: Ast,
     subjectCode: String,
@@ -842,7 +842,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
   }
 
   /** Creates an equality check for an expression pattern against a subject field access. */
-  private def astForExpressionPatternInTupleContext(
+  protected def astForExpressionPatternInTupleContext(
     ep: ExpressionPatternSyntax,
     subjectAst: Ast,
     subjectCode: String,
@@ -855,7 +855,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
   }
 
   /** Creates a variable binding assignment for a pattern element against a subject field access. */
-  private def astForBindingInTupleContext(
+  protected def astForBindingInTupleContext(
     varName: String,
     subjectAst: Ast,
     subjectCode: String,
@@ -869,7 +869,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
     List(createAssignmentCallAst(anchorNode, Ast(lhsNode), subjectAst, assignCode))
   }
 
-  private def astsForBindingTuplePatternInSwitchContext(
+  protected def astsForBindingTuplePattern(
     tuplePat: TuplePatternSyntax,
     subjectBase: String,
     subjectFieldPath: List[String],
@@ -881,7 +881,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
       val subjectAst  = createFieldAccessChain(subjectBase, currentPath, node)
       element.pattern match {
         case inner: TuplePatternSyntax =>
-          astsForBindingTuplePatternInSwitchContext(inner, subjectBase, currentPath, node)
+          astsForBindingTuplePattern(inner, subjectBase, currentPath, node)
         case isType: IsTypePatternSyntax =>
           astForIsTypePatternInTupleContext(isType, subjectAst, subjectCode, node)
         case ep: ExpressionPatternSyntax =>
@@ -891,7 +891,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
         case vb: ValueBindingPatternSyntax =>
           vb.pattern match {
             case inner: TuplePatternSyntax =>
-              astsForBindingTuplePatternInSwitchContext(inner, subjectBase, currentPath, node)
+              astsForBindingTuplePattern(inner, subjectBase, currentPath, node)
             case _ =>
               astForBindingInTupleContext(code(vb.pattern), subjectAst, subjectCode, tuplePat)
           }
@@ -902,7 +902,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
   }
 
   /** Determines whether an expression inside a tuple represents a binding (let/var pattern). */
-  private def isBindingExpression(expr: ExprSyntax): Boolean = expr match {
+  protected def isBindingExpression(expr: ExprSyntax): Boolean = expr match {
     case p: PatternExprSyntax =>
       p.pattern match {
         case _: ValueBindingPatternSyntax => true
@@ -913,7 +913,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
   }
 
   /** Dispatches a PatternSyntax inside a tuple context to the appropriate de-sugaring. */
-  private def astsForPatternInTupleContext(
+  protected def astsForPatternInTupleContext(
     pattern: PatternSyntax,
     subjectAst: Ast,
     subjectCode: String,
@@ -932,7 +932,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
       List(callAst(eqNode, List(subjectAst, rhsAst)))
   }
 
-  private def astsForBindingTupleExprInSwitchContext(
+  protected def astsForBindingTupleExpr(
     tupleExpr: TupleExprSyntax,
     subjectBase: String,
     subjectFieldPath: List[String],
@@ -945,7 +945,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
       val subjectAst  = createFieldAccessChain(subjectBase, currentPath, node)
       element.expression match {
         case inner: TupleExprSyntax =>
-          astsForBindingTupleExprInSwitchContext(inner, subjectBase, currentPath, node, allBindings)
+          astsForBindingTupleExpr(inner, subjectBase, currentPath, node, allBindings)
         case _ if allBindings || isBindingExpression(element.expression) =>
           val varName = extractBindingName(element.expression)
           astForBindingInTupleContext(varName, subjectAst, subjectCode, tupleExpr)
@@ -966,7 +966,7 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
     *   - `DeclReferenceExprSyntax` (`a` in `case let (a, b):`)
     *   - `PatternExprSyntax(ValueBindingPatternSyntax(IdentifierPatternSyntax))` (`var a` in `case (var a, var b):`)
     */
-  private def extractBindingName(expr: ExprSyntax): String = {
+  protected def extractBindingName(expr: ExprSyntax): String = {
     expr match {
       case d: DeclReferenceExprSyntax => code(d)
       case p: PatternExprSyntax =>

joern-cli/frontends/swiftsrc2cpg/src/main/scala/io/joern/swiftsrc2cpg/astcreation/AstForPatternSyntaxCreator.scala

@@ -35,8 +35,9 @@ trait AstForPatternSyntaxCreator(implicit withSchemaValidation: ValidationMode)
 
   private def astForMissingPatternSyntax(@unused node: MissingPatternSyntax): Ast = Ast()
 
-  // TODO: implement astForTuplePatternSyntax for non-switch contexts (e.g. if-case expressions).
-  // Switch-context handling is done via astsForBindingTuplePatternInSwitchContext in AstForExprSyntaxCreator.
+  // Tuple patterns in switch-case and if-case/guard-case conditions are handled via
+  // astsForBindingTuplePattern / astForExpressionTuplePattern in AstForExprSyntaxCreator.
+  // This handler covers remaining contexts (e.g. bare pattern matching) which are not yet implemented.
   private def astForTuplePatternSyntax(node: TuplePatternSyntax): Ast = notHandledYet(node)
 
   private def localForValueBindingPatternSyntax(

joern-cli/frontends/swiftsrc2cpg/src/main/scala/io/joern/swiftsrc2cpg/astcreation/AstForSyntaxCreator.scala

@@ -263,14 +263,128 @@ trait AstForSyntaxCreator(implicit withSchemaValidation: ValidationMode) { this:
   private def astForLayoutRequirementSyntax(node: LayoutRequirementSyntax): Ast                 = notHandledYet(node)
 
   private def astForMatchingPatternConditionSyntax(node: MatchingPatternConditionSyntax): Ast = {
-    val lhsAst = astForNode(node.pattern)
-    val rhsAst = astForNode(node.initializer.value)
+    val initValue = node.initializer.value
+
+    // Detect tuple pattern variants
+    val maybeTuplePattern: Option[TuplePatternSyntax] = node.pattern match {
+      case tp: TuplePatternSyntax => Some(tp)
+      case vb: ValueBindingPatternSyntax =>
+        vb.pattern match {
+          case tp: TuplePatternSyntax => Some(tp)
+          case _                      => None
+        }
+      case _ => None
+    }
+
+    val maybeTupleExpr: Option[TupleExprSyntax] = node.pattern match {
+      case ep: ExpressionPatternSyntax =>
+        ep.expression match {
+          case te: TupleExprSyntax => Some(te)
+          case _                   => None
+        }
+      case vb: ValueBindingPatternSyntax =>
+        vb.pattern match {
+          case ep: ExpressionPatternSyntax =>
+            ep.expression match {
+              case te: TupleExprSyntax => Some(te)
+              case _                   => None
+            }
+          case _ => None
+        }
+      case _ => None
+    }
 
-    val tpe       = Defines.Bool
-    val op        = Operators.equals
-    val callNode_ = createStaticCallNode(node, code(node), op, op, tpe)
-    val argAsts   = List(lhsAst, rhsAst)
-    callAst(callNode_, argAsts)
+    (maybeTuplePattern, maybeTupleExpr) match {
+      case (Some(tuplePat), _) =>
+        astForTuplePatternInConditionContext(node, tuplePat, initValue)
+      case (_, Some(tupleExpr)) =>
+        astForTupleExprInConditionContext(node, tupleExpr, initValue)
+      case _ =>
+        // Original behavior for non-tuple patterns
+        val lhsAst    = astForNode(node.pattern)
+        val rhsAst    = astForNode(initValue)
+        val tpe       = Defines.Bool
+        val op        = Operators.equals
+        val callNode_ = createStaticCallNode(node, code(node), op, op, tpe)
+        val argAsts   = List(lhsAst, rhsAst)
+        callAst(callNode_, argAsts)
+    }
+  }
+
+  /** De-sugars a tuple in an if-case / guard-case condition.
+    *
+    * Creates a block: { <tmp> = initValue; ...desugarAsts... } where the de-sugaring is provided by `desugarFn`.
+    *
+    * Locals are added to `localAstParentStack.head`. For `if` conditions this is the IF control structure node. For
+    * `guard` conditions this is the enclosing method/block scope (matching existing `guard let` behavior).
+    */
+  private def astForTupleInConditionContext(
+    node: SwiftNode,
+    initValue: SwiftNode,
+    arity: Int,
+    desugarFn: String => List[Ast]
+  ): Ast = {
+    val blockNode_ = blockNode(node)
+    scope.pushNewBlockScope(blockNode_)
+    localAstParentStack.push(blockNode_)
+
+    val tmpName      = scopeLocalUniqueName("tmp")
+    val tmpLocalNode = localNode(node, tmpName, tmpName, Defines.Any).order(0)
+    diffGraph.addEdge(localAstParentStack.head, tmpLocalNode, EdgeTypes.AST)
+    scope.addVariable(tmpName, tmpLocalNode, Defines.Any, VariableScopeManager.ScopeType.BlockScope)
+
+    val tmpIdentNode = identifierNode(node, tmpName, tmpName, Defines.Any)
+    scope.addVariableReference(tmpName, tmpIdentNode, Defines.Any, EvaluationStrategies.BY_REFERENCE)
+    val initAst   = astForNode(initValue)
+    val assignAst = createAssignmentCallAst(node, Ast(tmpIdentNode), initAst, s"$tmpName = ${code(initValue)}")
+
+    val desugarAsts = desugarFn(tmpName)
+
+    // Emit an isTupleN check as the final expression in the condition block
+    val op               = Defines.createIsTupleOperator(arity)
+    val isTupleCode      = s"$op($tmpName)"
+    val isTupleNode      = createStaticCallNode(node, isTupleCode, op, op, Defines.Bool)
+    val tmpIdentForCheck = identifierNode(node, tmpName, tmpName, Defines.Any)
+    scope.addVariableReference(tmpName, tmpIdentForCheck, Defines.Any, EvaluationStrategies.BY_REFERENCE)
+    val isTupleAst = callAst(isTupleNode, List(Ast(tmpIdentForCheck)))
+
+    scope.popScope()
+    localAstParentStack.pop()
+
+    blockAst(blockNode_, (assignAst +: desugarAsts) :+ isTupleAst)
+  }
+
+  private def astForTuplePatternInConditionContext(
+    node: SwiftNode,
+    tuplePat: TuplePatternSyntax,
+    initValue: SwiftNode
+  ): Ast = {
+    val arity = tuplePat.elements.children.size
+    astForTupleInConditionContext(
+      node,
+      initValue,
+      arity,
+      tmpName => astsForBindingTuplePattern(tuplePat, tmpName, List.empty, node)
+    )
+  }
+
+  private def astForTupleExprInConditionContext(
+    node: SwiftNode,
+    tupleExpr: TupleExprSyntax,
+    initValue: SwiftNode
+  ): Ast = {
+    val arity = tupleExpr.elements.children.size
+    astForTupleInConditionContext(
+      node,
+      initValue,
+      arity,
+      tmpName =>
+        if (isBindingTupleExpr(tupleExpr)) {
+          astsForBindingTupleExpr(tupleExpr, tmpName, List.empty, node)
+        } else {
+          List(astForExpressionTuplePattern(tupleExpr, tmpName, List.empty, node))
+        }
+    )
   }
 
   private def astForMemberBlockItemSyntax(node: MemberBlockItemSyntax): Ast = notHandledYet(node)
@@ -305,24 +419,50 @@ trait AstForSyntaxCreator(implicit withSchemaValidation: ValidationMode) { this:
   private def astForOptionalBindingConditionSyntax(node: OptionalBindingConditionSyntax): Ast = {
     val typeFullName = node.typeAnnotation.fold(Defines.Any)(t => AstCreatorHelper.cleanType(code(t.`type`)))
 
-    node.pattern match {
-      case ident: IdentifierPatternSyntax =>
-        val tpeFromTypeMap = fullnameProvider.typeFullname(ident)
-        localForOptionalBindingConditionSyntax(node, code(ident.identifier), tpeFromTypeMap.getOrElse(typeFullName))
-      case _ => // do nothing
+    // Detect tuple pattern: Swift parser may produce TuplePatternSyntax or
+    // ExpressionPatternSyntax wrapping TupleExprSyntax for `if let (a, b) = x`
+    val maybeTupleExpr: Option[TupleExprSyntax] = node.pattern match {
+      case tp: TuplePatternSyntax =>
+        // Direct tuple pattern — use TuplePatternInConditionContext
+        return node.initializer match {
+          case Some(init) => astForTuplePatternInConditionContext(node, tp, init.value)
+          case None       => Ast()
+        }
+      case ep: ExpressionPatternSyntax =>
+        ep.expression match {
+          case te: TupleExprSyntax => Some(te)
+          case _                   => None
+        }
+      case _ => None
     }
 
-    val initAst = node.initializer.map(astForNode)
-    if (initAst.isEmpty) {
-      Ast()
-    } else {
-      val patternAst = astForNode(node.pattern)
-      val tpe        = fullnameProvider.typeFullname(node.pattern).getOrElse(typeFullName)
-      registerType(tpe)
-      patternAst.root
-        .collect { case i: NewIdentifier => i }
-        .foreach(_.typeFullName(tpe))
-      createAssignmentCallAst(node, patternAst, initAst.head, code(node))
+    maybeTupleExpr match {
+      case Some(tupleExpr) =>
+        node.initializer match {
+          case Some(init) => astForTupleExprInConditionContext(node, tupleExpr, init.value)
+          case None       => Ast()
+        }
+      case None =>
+        // Original behavior for non-tuple patterns
+        node.pattern match {
+          case ident: IdentifierPatternSyntax =>
+            val tpeFromTypeMap = fullnameProvider.typeFullname(ident)
+            localForOptionalBindingConditionSyntax(node, code(ident.identifier), tpeFromTypeMap.getOrElse(typeFullName))
+          case _ => // do nothing
+        }
+
+        val initAst = node.initializer.map(astForNode)
+        if (initAst.isEmpty) {
+          Ast()
+        } else {
+          val patternAst = astForNode(node.pattern)
+          val tpe        = fullnameProvider.typeFullname(node.pattern).getOrElse(typeFullName)
+          registerType(tpe)
+          patternAst.root
+            .collect { case i: NewIdentifier => i }
+            .foreach(_.typeFullName(tpe))
+          createAssignmentCallAst(node, patternAst, initAst.head, code(node))
+        }
     }
   }