[swiftsrc2cpg] Call and type decl member/access rework

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

@@ -36,14 +36,12 @@ class AstCreator(
 
   protected val logger: Logger = LoggerFactory.getLogger(classOf[AstCreator])
 
-  protected val scope            = new SwiftVariableScopeManager()
-  protected val fullnameProvider = new FullnameProvider(typeMap)
-
-  protected val methodAstParentStack     = new Stack[NewNode]()
-  protected val typeRefIdStack           = new Stack[NewTypeRef]
-  protected val dynamicInstanceTypeStack = new Stack[String]
-  protected val localAstParentStack      = new Stack[NewBlock]()
-  protected val scopeLocalUniqueNames    = mutable.HashMap.empty[String, Int]
+  protected val scope                 = new SwiftVariableScopeManager()
+  protected val fullnameProvider      = new FullnameProvider(typeMap)
+  protected val methodAstParentStack  = new Stack[NewNode]()
+  protected val typeRefIdStack        = new Stack[NewTypeRef]
+  protected val localAstParentStack   = new Stack[NewBlock]()
+  protected val scopeLocalUniqueNames = mutable.HashMap.empty[String, Int]
 
   protected lazy val definedSymbols: Map[String, String] = {
     config.defines.map {
@@ -75,6 +73,7 @@ class AstCreator(
     val fakeGlobalMethod =
       methodNode(ast, name, name, fullName, None, path, Option(NodeTypes.TYPE_DECL), Option(fullName))
     methodAstParentStack.push(fakeGlobalMethod)
+    scope.pushNewTypeDeclScope(fullName)
     scope.pushNewMethodScope(fullName, name, fakeGlobalMethod, None)
     val sourceFileAst = astForNode(ast)
     val methodReturn  = methodReturnNode(ast, Defines.Any)
@@ -86,7 +85,7 @@ class AstCreator(
   }
 
   protected def astForNode(node: SwiftNode): Ast = node match {
-    case func: FunctionDeclLike             => astForFunctionLike(func)
+    case func: FunctionDeclLike             => astForFunctionLike(func, List.empty, None)
     case swiftToken: SwiftToken             => astForSwiftToken(swiftToken)
     case syntax: Syntax                     => astForSyntax(syntax)
     case exprSyntax: ExprSyntax             => astForExprSyntax(exprSyntax)

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

@@ -164,16 +164,38 @@ trait AstCreatorHelper(implicit withSchemaValidation: ValidationMode) { this: As
 
   protected def astForIdentifier(node: SwiftNode): Ast = {
     val identifierName = code(node)
-    val identNode      = identifierNode(node, identifierName)
-    val variableOption = scope.lookupVariable(identifierName)
-    val tpe = variableOption match {
-      case Some((_, variableTypeName)) if variableTypeName != Defines.Any => variableTypeName
-      case None if identNode.typeFullName != Defines.Any                  => identNode.typeFullName
-      case _                                                              => Defines.Any
+    if (scope.variableIsInTypeDeclScope(identifierName)) {
+      // we found it as member of the surrounding type decl
+      // (Swift does not allow to access any member / function of the outer class instance)
+      val tpe      = scope.typeDeclFullNameForMember(identifierName).getOrElse(typeForSelfExpression())
+      val selfNode = identifierNode(node, "self", "self", tpe)
+      scope.addVariableReference("self", selfNode, selfNode.typeFullName, EvaluationStrategies.BY_REFERENCE)
+
+      val variableOption = scope.lookupVariable(identifierName)
+      val callTpe        = variableOption.map(_._2).getOrElse(Defines.Any)
+      fieldAccessAst(node, node, Ast(selfNode), s"self.$identifierName", identifierName, callTpe)
+    } else {
+      if (config.swiftBuild && scope.lookupVariable(identifierName).isEmpty) {
+        val tpe      = typeForSelfExpression()
+        val selfNode = identifierNode(node, "self", "self", tpe)
+        scope.addVariableReference("self", selfNode, selfNode.typeFullName, EvaluationStrategies.BY_REFERENCE)
+
+        val callTpe = fullnameProvider.typeFullname(node).getOrElse(Defines.Any)
+        fieldAccessAst(node, node, Ast(selfNode), s"self.$identifierName", identifierName, callTpe)
+      } else {
+        // otherwise it must come from a variable (potentially captured from an outer scope)
+        val identNode      = identifierNode(node, identifierName)
+        val variableOption = scope.lookupVariable(identifierName)
+        val tpe = variableOption match {
+          case Some((_, variableTypeName)) if variableTypeName != Defines.Any => variableTypeName
+          case None if identNode.typeFullName != Defines.Any                  => identNode.typeFullName
+          case _                                                              => Defines.Any
+        }
+        identNode.typeFullName = tpe
+        scope.addVariableReference(identifierName, identNode, tpe, EvaluationStrategies.BY_REFERENCE)
+        Ast(identNode)
+      }
     }
-    identNode.typeFullName = tpe
-    scope.addVariableReference(identifierName, identNode, tpe, EvaluationStrategies.BY_REFERENCE)
-    Ast(identNode)
   }
 
   protected def registerType(typeFullName: String): Unit = {
@@ -339,8 +361,12 @@ trait AstCreatorHelper(implicit withSchemaValidation: ValidationMode) { this: As
   private def typeNameInfoForNode(node: SwiftNode, name: String): TypeInfo = {
     fullnameProvider.declFullname(node) match {
       case Some(declFullname) =>
-        registerType(declFullname)
-        TypeInfo(name, declFullname)
+        val cleanedFullName = if (declFullname.contains("(")) {
+          val fullName = declFullname.substring(0, declFullname.indexOf("("))
+          fullName.substring(0, fullName.lastIndexOf("."))
+        } else declFullname
+        registerType(cleanedFullName)
+        TypeInfo(name, cleanedFullName)
       case None =>
         val (_, declFullname) = calcNameAndFullName(name)
         registerType(declFullname)