[kotlin2cpg] Fix Incorrect Package-Level Global Variable Handling (#5839)

* [kotlin2cpg] Add tests for both cases in the issue

* Removed Frontend Validation in test

Author: SuperUserDone

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/ast/AstCreator.scala

@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.it.unimi.dsi.fastutil.objects.s
 object AstCreator {
   case class AnonymousObjectContext(declaration: KtElement)
   case class BindingInfo(node: NewBinding, edgeMeta: Seq[(NewNode, NewNode, String)])
-  case class ClosureBindingDef(node: NewClosureBinding, captureEdgeTo: NewMethodRef, refEdgeTo: NewNode)
+  case class ClosureBindingDef(node: NewClosureBinding, captureEdgeTo: Option[NewMethodRef], refEdgeTo: NewNode)
 
   case class ReceiverInfo(
     ctorParamAst: Ast,
@@ -259,7 +259,7 @@ class AstCreator(
 
     closureBindingDefQueue.foreach { case ClosureBindingDef(node, captureEdgeTo, refEdgeTo) =>
       diffGraph.addNode(node)
-      diffGraph.addEdge(captureEdgeTo, node, EdgeTypes.CAPTURE)
+      captureEdgeTo.foreach(diffGraph.addEdge(_, node, EdgeTypes.CAPTURE))
       diffGraph.addEdge(node, refEdgeTo, EdgeTypes.REF)
     }
   }

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/ast/AstForFunctionsCreator.scala

@@ -78,7 +78,41 @@ trait AstForFunctionsCreator(implicit withSchemaValidation: ValidationMode) exte
     val fullName = nameRenderer.combineFunctionFullName(descFullName, signature)
 
     val _methodNode = methodNode(ktFn, ktFn.getName, fullName, signature, relativizedPath)
-    scope.pushNewScope(_methodNode)
+    val closureBindingEntriesForCaptured =
+      if (ktFn.getName == "main") {
+        scope
+          .pushClosureScope(_methodNode)
+          .collect { case node: NewLocal => NodeContext(node, node.name, node.typeFullName) }
+          .map { capturedNodeContext =>
+            val closureBindingId = s"${_methodNode.fullName}:${capturedNodeContext.name}"
+            val closureBinding   = closureBindingNode(closureBindingId, EvaluationStrategies.BY_REFERENCE)
+            (closureBinding, capturedNodeContext)
+          }
+      } else {
+        scope.pushNewScope(_methodNode)
+        List.empty
+      }
+    val methodRefForCapture =
+      if (closureBindingEntriesForCaptured.nonEmpty) {
+        val methodTypeDeclFullName = fullName.split(":").head
+        Some(methodRefNode(ktFn, ktFn.getName, fullName, methodTypeDeclFullName))
+      } else {
+        None
+      }
+
+    val localsForCaptured = closureBindingEntriesForCaptured.map { case (closureBinding, capturedNodeContext) =>
+      val node =
+        localNode(
+          ktFn,
+          capturedNodeContext.name,
+          capturedNodeContext.name,
+          capturedNodeContext.typeFullName,
+          closureBinding.closureBindingId
+        )
+      scope.addToScope(capturedNodeContext.name, node)
+      node
+    }
+
     methodAstParentStack.push(_methodNode)
 
     val isExtensionMethod = funcDesc.getExtensionReceiverParameter != null
@@ -128,7 +162,8 @@ trait AstForFunctionsCreator(implicit withSchemaValidation: ValidationMode) exte
         astForParameter(p, valueParamStartIndex + idx - 1)
       }
     val bodyAst = Option(ktFn.getBodyBlockExpression) match {
-      case Some(bodyBlockExpression) => astForBlock(bodyBlockExpression, None, None)
+      case Some(bodyBlockExpression) =>
+        astForBlock(bodyBlockExpression, None, None, localsForCaptures = localsForCaptured)
       case None =>
         Option(ktFn.getBodyExpression)
           .map { expr =>
@@ -141,16 +176,21 @@ trait AstForFunctionsCreator(implicit withSchemaValidation: ValidationMode) exte
                 val returnAst_           = returnAst(returnNode(expr, Constants.RetCode), Seq(lastStatementAst))
                 (allStatementsButLast ++ Seq(returnAst_)).toList
               } else List()
-            blockAst(bodyBlock, blockChildAsts)
+            blockAst(bodyBlock, localsForCaptured.map(Ast(_)) ++ blockChildAsts)
           }
           .getOrElse {
             val bodyBlock = blockNode(ktFn, "<empty>", TypeConstants.Any)
-            blockAst(bodyBlock, List[Ast]())
+            blockAst(bodyBlock, localsForCaptured.map(Ast(_)))
           }
     }
     methodAstParentStack.pop()
     scope.popScope()
 
+    val closureBindingDefs = closureBindingEntriesForCaptured.map { case (closureBinding, node) =>
+      ClosureBindingDef(closureBinding, methodRefForCapture, node.node)
+    }
+    closureBindingDefs.foreach(closureBindingDefQueue.prepend)
+
     val explicitTypeName  = Option(ktFn.getTypeReference).map(_.getText).getOrElse(TypeConstants.Any)
     val typeFullName      = registerType(nameRenderer.typeFullName(funcDesc.getReturnType).getOrElse(explicitTypeName))
     val _methodReturnNode = methodReturnNode(ktFn, typeFullName)
@@ -183,6 +223,7 @@ trait AstForFunctionsCreator(implicit withSchemaValidation: ValidationMode) exte
     val annotationEntries = ktFn.getAnnotationEntries.asScala.map(astForAnnotationEntry).toSeq
     methodAst(_methodNode, thisParameterAsts ++ methodParametersAsts, bodyAst, _methodReturnNode, modifiers)
       .withChildren(annotationEntries)
+      .withChildren(methodRefForCapture.map(Ast(_)).toSeq)
   }
 
   private def astsForDestructuring(param: KtParameter, backingParamName: Option[String] = None): Seq[Ast] = {
@@ -485,7 +526,7 @@ trait AstForFunctionsCreator(implicit withSchemaValidation: ValidationMode) exte
 
     scope.popScope()
     val closureBindingDefs = closureBindingEntriesForCaptured.collect { case (closureBinding, node) =>
-      ClosureBindingDef(closureBinding, _methodRefNode, node.node)
+      ClosureBindingDef(closureBinding, Some(_methodRefNode), node.node)
     }
     closureBindingDefs.foreach(closureBindingDefQueue.prepend)
     lambdaAstQueue.prepend(lambdaMethodAst)
@@ -656,7 +697,7 @@ trait AstForFunctionsCreator(implicit withSchemaValidation: ValidationMode) exte
 
     scope.popScope()
     val closureBindingDefs = closureBindingEntriesForCaptured.collect { case (closureBinding, node) =>
-      ClosureBindingDef(closureBinding, _methodRefNode, node.node)
+      ClosureBindingDef(closureBinding, Some(_methodRefNode), node.node)
     }
     closureBindingDefs.foreach(closureBindingDefQueue.prepend)
     lambdaAstQueue.prepend(lambdaMethodAst)

joern-cli/frontends/kotlin2cpg/src/test/scala/io/joern/kotlin2cpg/validation/IdentifierReferencesTests.scala

@@ -2,8 +2,11 @@ package io.joern.kotlin2cpg.validation
 
 import io.joern.kotlin2cpg.testfixtures.KotlinCode2CpgFixture
 import io.shiftleft.codepropertygraph.generated.Operators
+import io.shiftleft.codepropertygraph.generated.edges.Capture
 import io.shiftleft.codepropertygraph.generated.nodes.{Identifier, Local, MethodParameterIn}
 import io.shiftleft.semanticcpg.language.*
+import io.shiftleft.semanticcpg.validation.PostFrontendValidator
+import io.shiftleft.codepropertygraph.generated.nodes.Member
 
 // TODO: also add test with refs inside TYPE_DECL
 
@@ -203,4 +206,49 @@ class IdentifierReferencesTests extends KotlinCode2CpgFixture(withOssDataflow =
       methodParam.name shouldBe "this"
     }
   }
+
+  "CPG for code with a package-level global referenced from main" should {
+    lazy val cpg = code("""
+        |package com.example
+        |
+        |val globalVar = 42
+        |
+        |fun main(): Unit {
+        |  print(globalVar)
+        |}
+        |""".stripMargin)
+    "have a LOCAL node for the global in <global> method" in {
+      val List(globalMethod) = cpg.method.nameExact("<global>").l
+      val List(globalLocal)  = globalMethod.local.nameExact("globalVar").l
+      globalLocal.name shouldBe "globalVar"
+      globalLocal.typeFullName shouldBe "int"
+      globalLocal.closureBindingId shouldBe None
+    }
+
+    "have a LOCAL with closure binding in main method" in {
+      val List(mainLocal) = cpg.method.nameExact("main").local.nameExact("globalVar").l
+      mainLocal.closureBindingId should not be None
+      mainLocal.closureBindingId.get shouldBe "com.example.main:void():globalVar"
+    }
+
+    "have a CLOSURE_BINDING connecting the two LOCALs" in {
+      val List(globalMethod) = cpg.method.nameExact("<global>").l
+      val List(globalLocal)  = globalMethod.local.nameExact("globalVar").l
+      val bindings           = globalLocal.closureBinding.l
+      bindings.size shouldBe 1
+      bindings.head.closureBindingId should not be None
+      bindings.head.closureBindingId.get shouldBe "com.example.main:void():globalVar"
+    }
+
+    "have a CAPTURE edge from a METHOD_REF for main to the CLOSURE_BINDING" in {
+      cpg.methodRef.methodFullNameExact("com.example.main:void()").size shouldBe 1
+      cpg.methodRef.methodFullNameExact("com.example.main:void()").outE.collectAll[Capture].size shouldBe 1
+    }
+
+    "have identifier in main referencing the LOCAL in main" in {
+      val List(idInMain)    = cpg.method.nameExact("main").ast.isIdentifier.nameExact("globalVar").l
+      val List(localInMain) = cpg.method.nameExact("main").local.nameExact("globalVar").l
+      idInMain.refsTo.l shouldBe List(localInMain)
+    }
+  }
 }