fix for review comment

Author: max-leuthaeuser

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

@@ -164,28 +164,15 @@ trait AstCreatorHelper(implicit withSchemaValidation: ValidationMode) { this: As
 
   protected def astForIdentifier(node: SwiftNode): Ast = {
     val identifierName = code(node)
-    // scoping rules for self access:
-    // 1) if identifier is in local method scope it shadows everything else:
-    if (scope.variableIsInMethodScope(identifierName)) {
-      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)
-    } else if (scope.variableIsInTypeDeclScope(identifierName)) {
-      // 2) we found it as member of the surrounding type decl:
+    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      = typeForSelfExpression()
       val selfNode = identifierNode(node, "self", "self", tpe)
       scope.addVariableReference("self", selfNode, selfNode.typeFullName, EvaluationStrategies.BY_REFERENCE)
       fieldAccessAst(node, node, Ast(selfNode), s"self.$identifierName", identifierName, tpe)
     } else {
-      // 3) default handling, it must come from the outer scope somewhere
+      // otherwise it must come from the outer scope somewhere
       val identNode      = identifierNode(node, identifierName)
       val variableOption = scope.lookupVariable(identifierName)
       val tpe = variableOption match {

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

@@ -612,8 +612,10 @@ trait AstForDeclSyntaxCreator(implicit withSchemaValidation: ValidationMode) {
     val MethodInfo(methodName, methodFullName, signature, returnType) = methodInfo
     val methodFullNameAndSignature                                    = methodInfo.fullNameAndSignature
 
-    val shouldCreateFunctionReference =
-      typeRefIdStack.isEmpty || node.isInstanceOf[ClosureExprSyntax] || node.isInstanceOf[AccessorDeclSyntax]
+    val shouldCreateFunctionReference = typeRefIdStack.isEmpty ||
+      methodAstParentStack.headOption.exists(_.isInstanceOf[NewMethod]) ||
+      node.isInstanceOf[ClosureExprSyntax] ||
+      node.isInstanceOf[AccessorDeclSyntax]
     val methodRefNode_ = if (!shouldCreateFunctionReference) { None }
     else { Option(methodRefNode(node, methodName, methodFullNameAndSignature, methodFullNameAndSignature)) }
     val capturingRefNode = methodRefNode_.orElse(typeRefIdStack.headOption)

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

@@ -282,10 +282,10 @@ class SimpleAstCreationPassTest extends AstSwiftSrc2CpgSuite {
           |class Foo {
           |  let f: String = "b"
           |  func foo() -> String {
-          |    func closure() -> String {
+          |    func bar() -> String {
           |      return handleF(f)
           |    }
-          |    return closure()
+          |    return bar()
           |  }
           |}
           |""".stripMargin)
@@ -297,6 +297,16 @@ class SimpleAstCreationPassTest extends AstSwiftSrc2CpgSuite {
         id.typeFullName shouldBe "Test0.swift:<global>.Foo"
         fieldName.canonicalName shouldBe "f"
       }
+
+      val List(fooMethod)          = cpg.method.nameExact("foo").l
+      val List(fooBlock)           = fooMethod.astChildren.isBlock.l
+      val List(barRef)             = fooBlock.astChildren.isMethodRef.l
+      val List(closureBindingSelf) = barRef.captureOut.l
+      closureBindingSelf.closureBindingId shouldBe Option("Test0.swift:<global>.Foo.foo.bar:self")
+
+      val List(barMethod)      = cpg.method.nameExact("bar").l
+      val List(barMethodBlock) = barMethod.astChildren.isBlock.l
+      barMethodBlock.astChildren.isLocal.name("f") shouldBe empty
     }
 
     "have correct structure for implicit self access from within nested functions with shadowing" in {
@@ -306,10 +316,10 @@ class SimpleAstCreationPassTest extends AstSwiftSrc2CpgSuite {
           |  let f: String = "b"
           |  func foo() -> String {
           |    let f: String = "c"
-          |    func closure() -> String {
+          |    func bar() -> String {
           |      return handleF(f)
           |    }
-          |    return closure()
+          |    return bar()
           |  }
           |}
           |""".stripMargin)
@@ -321,6 +331,23 @@ class SimpleAstCreationPassTest extends AstSwiftSrc2CpgSuite {
         fLocal.name shouldBe "f"
         fLocal.typeFullName shouldBe Defines.String
       }
+      val List(fooMethod)                           = cpg.method.nameExact("foo").l
+      val List(fooBlock)                            = fooMethod.astChildren.isBlock.l
+      val List(fooLocalF)                           = fooBlock.astChildren.isLocal.nameExact("f").l
+      val List(barRef)                              = fooBlock.astChildren.isMethodRef.l
+      val List(closureBindingF, closureBindingSelf) = barRef.captureOut.l
+      closureBindingF.closureBindingId shouldBe Option("Test0.swift:<global>.Foo.foo.bar:f")
+      closureBindingF.refOut.head shouldBe fooLocalF
+      closureBindingF.evaluationStrategy shouldBe EvaluationStrategies.BY_REFERENCE
+      closureBindingSelf.closureBindingId shouldBe Option("Test0.swift:<global>.Foo.foo.bar:self")
+
+      val List(barMethod)      = cpg.method.nameExact("bar").l
+      val List(barMethodBlock) = barMethod.astChildren.isBlock.l
+      val List(barLocal)       = barMethodBlock.astChildren.isLocal.name("f").l
+      barLocal.closureBindingId shouldBe Option("Test0.swift:<global>.Foo.foo.bar:f")
+
+      val List(identifierF) = barMethodBlock.ast.isIdentifier.nameExact("f").l
+      identifierF.refOut.head shouldBe barLocal
     }
 
     "have correct structure for implicit self access except for variable in closure" in {
@@ -329,7 +356,7 @@ class SimpleAstCreationPassTest extends AstSwiftSrc2CpgSuite {
           |  let f: String = "f"
           |  class Bar {
           |    let b = "b"
-          |    func bar() {
+          |    func foo() {
           |      let compare = { (s1: String, s2: String) -> Bool in
           |        let f: Int = 1
           |        handleB(b)
@@ -356,6 +383,20 @@ class SimpleAstCreationPassTest extends AstSwiftSrc2CpgSuite {
         fLocal.name shouldBe "f"
         fLocal.typeFullName shouldBe Defines.Int
       }
+
+      val List(fooMethod)  = cpg.method.nameExact("foo").l
+      val List(fooBlock)   = fooMethod.astChildren.isBlock.l
+      val List(compareRef) = fooBlock.ast.isMethodRef.l
+      compareRef.captureOut shouldBe empty
+
+      val List(compareClosure)                              = cpg.method.nameExact("<lambda>0").l
+      val List(barMethodBlock)                              = compareClosure.astChildren.isBlock.l
+      val List(barLocal)                                    = barMethodBlock.astChildren.isLocal.name("f").l
+      val List(identifierFFromLocalDecl, identifierFInCall) = barMethodBlock.ast.isIdentifier.nameExact("f").l
+      identifierFFromLocalDecl.refOut.head shouldBe barLocal
+      identifierFFromLocalDecl.lineNumber shouldBe Some(8)
+      identifierFInCall.refOut.head shouldBe barLocal
+      identifierFInCall.lineNumber shouldBe Some(10)
     }
 
     "have correct structure for implicit self access except for parameters" in {