[swiftsrc2cpg] Proper closure call handling (#5685)

Author: max-leuthaeuser

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

@@ -9,6 +9,8 @@ import org.apache.commons.lang3.StringUtils
 object AstCreatorHelper {
 
   private val TagsToKeepInFullName = List("<anonymous>", "<lambda>", "<global>", "<type>", "<extension>", "<wildcard>")
+  private val ReturnTypeMatcher    = """^\(.*\)(->|:)(.+)$""".r
+  private val ClosureSignatureMatcher = """^(\(.*\))\s*(.*)\s*->(.+)$""".r
 
   /** Removes generic type parameters from qualified names while preserving special tags.
     *
@@ -84,9 +86,15 @@ object AstCreatorHelper {
       case "Dictionary" => Defines.Dictionary
       case "Nil"        => Defines.Nil
       // Special patterns with specific handling
-      case t if t.startsWith("[") && t.endsWith("]") => Defines.Array
-      case t if t.contains("=>") || t.contains("->") => Defines.Function
-      case t if t.contains("( ")                     => t.substring(0, t.indexOf("( "))
+      case t if t.startsWith("[") && t.endsWith("]")         => Defines.Array
+      case ClosureSignatureMatcher(params, mods, returnType) =>
+        // "throws" is the only modifier that swiftc keeps
+        // so we have to restore it here to keep signatures
+        // consistent between runs with compiler support and without.
+        val m = if (mods.contains("throws")) { "throws" }
+        else ""
+        s"${Defines.Function}<$params$m->$returnType>".replace(" ", "")
+      case t if t.contains("( ") => t.substring(0, t.indexOf("( "))
       // Default case
       case typeStr => typeStr
     }
@@ -162,7 +170,7 @@ trait AstCreatorHelper(implicit withSchemaValidation: ValidationMode) { this: As
       case None if identNode.typeFullName != Defines.Any                  => identNode.typeFullName
       case _                                                              => Defines.Any
     }
-    val typedIdentNode = identNode.typeFullName(tpe)
+    identNode.typeFullName = tpe
     scope.addVariableReference(identifierName, identNode, tpe, EvaluationStrategies.BY_REFERENCE)
     Ast(identNode)
   }
@@ -191,8 +199,6 @@ trait AstCreatorHelper(implicit withSchemaValidation: ValidationMode) { this: As
     }
   }
 
-  private val ReturnTypeMatcher = """\(.*\)(->|:)(.+)""".r
-
   protected def methodInfoForFunctionDeclLike(node: FunctionDeclLike): MethodInfo = {
     val name = calcMethodName(node)
     fullnameProvider.declFullname(node) match {
@@ -226,9 +232,16 @@ trait AstCreatorHelper(implicit withSchemaValidation: ValidationMode) { this: As
             val returnType = cleanType(code(s.returnClause.`type`))
             (s"${paramSignature(s.parameterClause)}->$returnType", returnType)
           case c: ClosureExprSyntax =>
-            val returnType      = c.signature.flatMap(_.returnClause).fold(Defines.Any)(r => cleanType(code(r.`type`)))
-            val paramClauseCode = c.signature.flatMap(_.parameterClause).fold("()")(paramSignature)
-            (s"$paramClauseCode->$returnType", returnType)
+            fullnameProvider.typeFullnameRaw(node) match {
+              case Some(tpe) =>
+                val signature  = tpe
+                val returnType = ReturnTypeMatcher.findFirstMatchIn(signature).map(_.group(2)).getOrElse(Defines.Any)
+                (signature, returnType)
+              case _ =>
+                val returnType = c.signature.flatMap(_.returnClause).fold(Defines.Any)(r => cleanType(code(r.`type`)))
+                val paramClauseCode = c.signature.flatMap(_.parameterClause).fold("()")(paramSignature)
+                (s"$paramClauseCode->$returnType", returnType)
+            }
         }
         registerType(returnType)
         MethodInfo(methodName, methodFullName, signature, returnType)

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

@@ -705,7 +705,7 @@ trait AstForDeclSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
         List.empty[Ast]
     }
 
-    val methodReturnNode_ = methodReturnNode(node, returnType, Some(returnType))
+    val methodReturnNode_ = methodReturnNode(node, returnType)
 
     val blockAst_ = blockAst(block, methodBlockContent ++ bodyStmtAsts)
     val astForMethod =

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

@@ -210,7 +210,6 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
     baseNode: NewNode,
     callName: String
   ): Ast = {
-
     val trailingClosureAsts            = callExpr.trailingClosure.toList.map(astForNode)
     val additionalTrailingClosuresAsts = callExpr.additionalTrailingClosures.children.map(c => astForNode(c.closure))
 
@@ -289,6 +288,8 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
               val thisTmpNode    = identifierNode(callee, tmpVarName)
               (fieldAccessAst, thisTmpNode, memberCode)
           }
+        case other if isRefToClosure(node, other) =>
+          return astForClosureCall(node)
         case _ =>
           val receiverAst = astForNode(callee)
           val thisNode    = identifierNode(callee, "this")
@@ -299,6 +300,48 @@ trait AstForExprSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
     }
   }
 
+  private def astForClosureCall(expr: FunctionCallExprSyntax): Ast = {
+    val tpe = fullnameProvider.typeFullname(expr).getOrElse(Defines.Any)
+    registerType(tpe)
+    val signature = fullnameProvider.typeFullnameRaw(expr.calledExpression).getOrElse(x2cpg.Defines.UnresolvedSignature)
+    val callName  = Defines.ClosureApplyMethodName
+    val callMethodFullname = s"${Defines.Function}<$signature>.$callName:$signature"
+    val baseAst            = astForNode(expr.calledExpression)
+
+    val trailingClosureAsts            = expr.trailingClosure.toList.map(astForNode)
+    val additionalTrailingClosuresAsts = expr.additionalTrailingClosures.children.map(c => astForNode(c.closure))
+
+    val args = expr.arguments.children.map(astForNode) ++ trailingClosureAsts ++ additionalTrailingClosuresAsts
+
+    val callExprCode = code(expr)
+    val callNode_ = callNode(
+      expr,
+      callExprCode,
+      callName,
+      callMethodFullname,
+      DispatchTypes.DYNAMIC_DISPATCH,
+      Option(signature),
+      Option(tpe)
+    )
+    callAst(callNode_, args, Option(baseAst))
+  }
+
+  private def isRefToClosure(func: FunctionCallExprSyntax, node: ExprSyntax): Boolean = {
+    if (!config.swiftBuild) {
+      // Early exit; without types from the compiler we will be unable to identify closure calls anyway.
+      // This saves us the typeFullname lookup below.
+      return false
+    }
+    node match {
+      case refExpr: DeclReferenceExprSyntax
+          if refExpr.baseName.isInstanceOf[identifier] && refExpr.argumentNames.isEmpty &&
+            fullnameProvider.declFullname(func).isEmpty &&
+            fullnameProvider.typeFullname(refExpr).exists(_.startsWith(s"${Defines.Function}<")) =>
+        true
+      case _ => false
+    }
+  }
+
   private def astForGenericSpecializationExprSyntax(node: GenericSpecializationExprSyntax): Ast = {
     astForNode(node.expression)
   }

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

@@ -207,22 +207,30 @@ trait AstNodeBuilder(implicit withSchemaValidation: ValidationMode) { this: AstC
 
   protected def createFunctionTypeAndTypeDecl(node: SwiftNode, methodNode: NewMethod): Unit = {
     registerType(methodNode.fullName)
+
+    val (inherits, bindingName) = if (node.isInstanceOf[ClosureExprSyntax]) {
+      val inheritsFunctionFullName = s"${Defines.Function}<${methodNode.signature}>"
+      registerType(inheritsFunctionFullName)
+      (Seq(inheritsFunctionFullName), Defines.ClosureApplyMethodName)
+    } else (Seq.empty, methodNode.name)
+
     val (astParentType, astParentFullName) = astParentInfo()
     val methodTypeDeclNode = typeDeclNode(
       node,
       methodNode.name,
       methodNode.fullName,
       methodNode.filename,
       methodNode.fullName,
-      astParentType,
-      astParentFullName
+      astParentType = astParentType,
+      astParentFullName = astParentFullName,
+      inherits = inherits
     )
 
     methodNode.astParentFullName = astParentFullName
     methodNode.astParentType = astParentType
 
     val functionBinding = NewBinding()
-      .name(methodNode.name)
+      .name(bindingName)
       .methodFullName(methodNode.fullName)
       .signature(methodNode.signature)
 

joern-cli/frontends/swiftsrc2cpg/src/main/scala/io/joern/swiftsrc2cpg/passes/SwiftTypeNodePass.scala

@@ -15,7 +15,7 @@ object SwiftTypeNodePass {
       override def fullToShortName(typeName: String): String = {
         typeName match {
           case name if name.endsWith(NamespaceTraversal.globalNamespaceName) => NamespaceTraversal.globalNamespaceName
-          case _ => typeName.split('.').lastOption.getOrElse(typeName)
+          case _ => typeName.takeWhile(_ != '<').split('.').lastOption.getOrElse(typeName)
         }
       }
 

joern-cli/frontends/swiftsrc2cpg/src/main/scala/io/joern/swiftsrc2cpg/utils/FullnameProvider.scala

@@ -20,7 +20,12 @@ private object FullnameProvider {
   }
 
   // TODO: provide the actual mapping from SwiftNode.toString (nodeKind) to ResolvedTypeInfo.nodeKind
-  private val NodeKindMapping = Map("DeclReferenceExprSyntax" -> "type_expr")
+  private val NodeKindMapping = Map(
+    "DeclReferenceExprSyntax" -> "type_expr",
+    "VariableDeclSyntax"      -> "var_decl",
+    "PatternBindingSyntax"    -> "var_decl",
+    "IdentifierPatternSyntax" -> "var_decl"
+  )
 }
 
 /** Provides functionality to resolve and retrieve fullnames for Swift types and declarations. Uses a type mapping to
@@ -92,6 +97,12 @@ class FullnameProvider(typeMap: SwiftFileLocalTypeMapping) {
     *   An optional String containing the type fullname if found
     */
   protected def typeFullname(range: (Int, Int), nodeKind: String): Option[String] = {
+    fullName(range, FullnameProvider.Kind.Type, nodeKind).map(AstCreatorHelper.cleanType)
+  }
+
+  /** Same as FullnameProvider.typeFullname but does no type name sanitation.
+    */
+  protected def typeFullnameRaw(range: (Int, Int), nodeKind: String): Option[String] = {
     fullName(range, FullnameProvider.Kind.Type, nodeKind).map(AstCreatorHelper.cleanName)
   }
 
@@ -124,6 +135,16 @@ class FullnameProvider(typeMap: SwiftFileLocalTypeMapping) {
     }
   }
 
+  /** Same as FullnameProvider.typeFullname but does no type name sanitation.
+    */
+  def typeFullnameRaw(node: SwiftNode): Option[String] = {
+    if (typeMap.isEmpty) return None
+    (node.startOffset, node.endOffset) match {
+      case (Some(start), Some(end)) => typeFullnameRaw((start, end), node.toString)
+      case _                        => None
+    }
+  }
+
   /** Retrieves the declaration fullname for a given Swift node. Extracts the start and end offsets from the node if
     * available. Returns None if typeMap is empty.
     *

joern-cli/frontends/swiftsrc2cpg/src/test/scala/io/joern/swiftsrc2cpg/passes/ast/AsyncTests.scala

@@ -29,10 +29,10 @@ class AsyncTests extends AstSwiftSrc2CpgSuite {
       val cpg                = code("func asyncGlobal3(fn: () throws -> Int) async rethrows { }")
       val List(asyncGlobal3) = cpg.method.internal.nameNot(NamespaceTraversal.globalNamespaceName).l
       asyncGlobal3.name shouldBe "asyncGlobal3"
-      asyncGlobal3.fullName shouldBe s"Test0.swift:<global>.asyncGlobal3:(fn:${Defines.Function})->ANY"
+      asyncGlobal3.fullName shouldBe s"Test0.swift:<global>.asyncGlobal3:(fn:Swift.Function<()throws->Int>)->ANY"
       val List(fn) = asyncGlobal3.parameter.l
       fn.name shouldBe "fn"
-      fn.typeFullName shouldBe Defines.Function
+      fn.typeFullName shouldBe "Swift.Function<()throws->Int>"
     }
 
     "testAsync4" in {