[pysrc2cpg] Represent imports as static calls (#6249)

* [pysrc2cpg] Represent imports as static calls

* Rename to "<operator

* Bump Version

Author: SuperUserDone

MODULE.bazel

@@ -3,7 +3,7 @@ module(name = "joern")
 bazel_dep(name = "rules_scala", version = "7.2.5")
 bazel_dep(name = "codepropertygraph")
 
-CODEPROPERTYGRAPH_VERSION = "bd34f991c710fb616d8c26e3d9385043bb22820f"
+CODEPROPERTYGRAPH_VERSION = "e7b6e8da670e4b58a64ba153d197041c25fd798a"
 
 BAZEL_TOOLING_VERSION = "4bcf42cc81b574b91699d696b504637677640871"
 

build.sbt

@@ -2,7 +2,7 @@ name                     := "joern"
 ThisBuild / organization := "io.joern"
 ThisBuild / scalaVersion := "3.8.3"
 
-val cpgVersion = "1.7.70"
+val cpgVersion = "1.7.74"
 
 lazy val joerncli          = Projects.joerncli
 lazy val querydb           = Projects.querydb

joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/PythonAstVisitorHelpers.scala

@@ -113,15 +113,13 @@ trait PythonAstVisitorHelpers(implicit withSchemaValidation: ValidationMode) { t
           case None            => Seq()
         })
 
-        val importCallNode =
-          createCall(
-            createIdentifierNode("import", Load, lineAndCol),
-            "import",
-            lineAndCol,
-            arguments,
-            Nil,
-            Some(importAstNode)
-          )
+        val importCallNode = nodeBuilder.callNode(
+          new AstPrinter("").print(importAstNode),
+          Operators.importCall,
+          DispatchTypes.STATIC_DISPATCH,
+          lineAndCol
+        )
+        addAstChildrenAsArguments(importCallNode, 1, arguments)
 
         val assignNode = createAssignment(importAssignLhsIdentifierNode, importCallNode, lineAndCol)
         assignNode
@@ -529,7 +527,7 @@ trait PythonAstVisitorHelpers(implicit withSchemaValidation: ValidationMode) { t
     addAstChildrenAsArguments(callNode, 1, lhsNode, rhsNode)
     // Do not include imports or function pointers
     val isImportCall = rhsNode match {
-      case c: NewCall => c.name == "import"
+      case c: NewCall => c.name == Operators.importCall
       case _          => false
     }
     if (!isImportCall && codeOf(rhsNode) != s"def ${codeOf(lhsNode)}(...)") {

joern-cli/frontends/pysrc2cpg/src/test/scala/io/joern/pysrc2cpg/cpg/ImportCpgTests.scala

@@ -1,6 +1,6 @@
 package io.joern.pysrc2cpg.cpg
 
-import io.shiftleft.codepropertygraph.generated.Operators
+import io.shiftleft.codepropertygraph.generated.{DispatchTypes, Operators}
 import io.shiftleft.semanticcpg.language.*
 import org.scalatest.freespec.AnyFreeSpec
 import org.scalatest.matchers.should.Matchers
@@ -15,10 +15,16 @@ class ImportCpgTests extends PySrc2CpgFixture with Matchers {
     val lhsIdentifier = assignment.argument(1).isIdentifier.head
     lhsIdentifier.code shouldBe "a"
 
-    val fromLiteral = assignment.argument(2).isCall.argument(1).head
+    val importCall = assignment.argument(2).isCall.head
+    importCall.name shouldBe Operators.importCall
+    importCall.methodFullName shouldBe Operators.importCall
+    importCall.dispatchType shouldBe DispatchTypes.STATIC_DISPATCH
+    importCall.receiver.l shouldBe empty
+
+    val fromLiteral = importCall.argument(1)
     fromLiteral.code shouldBe ""
 
-    val importedEntity = assignment.argument(2).isCall.argument(2).head
+    val importedEntity = importCall.argument(2)
     importedEntity.code shouldBe "a"
   }
 

joern-cli/frontends/pysrc2cpg/src/test/scala/io/joern/pysrc2cpg/passes/ImportsPassTests.scala

@@ -1,21 +1,22 @@
 package io.joern.pysrc2cpg.passes
 
 import io.joern.pysrc2cpg.testfixtures.PySrc2CpgFixture
+import io.shiftleft.codepropertygraph.generated.Operators
 import io.shiftleft.semanticcpg.language.*
 
 class ImportsPassTests extends PySrc2CpgFixture(withOssDataflow = false) {
 
   "For a simple import statement, there" should {
     lazy val cpg = code("import foo", "app.py")
     "be a create a call to `import`" in {
-      val List(callToImport) = cpg.call("import").l
+      val List(callToImport) = cpg.call(Operators.importCall).l
       callToImport.code shouldBe "import foo"
       val List(where, what) = callToImport.argument.l
       where.code shouldBe ""
       what.code shouldBe "foo"
     }
     "create an assignment with the import on the right-hand-side" in {
-      val List(assignment) = cpg.call("import").inAssignment.l
+      val List(assignment) = cpg.call(Operators.importCall).inAssignment.l
       assignment.target.code shouldBe "foo"
       assignment.source.code shouldBe "import foo"
     }
@@ -60,15 +61,15 @@ class ImportsPassTests extends PySrc2CpgFixture(withOssDataflow = false) {
   "For an import of the form `from... import`, it" should {
     lazy val cpg = code("from foo import Bar")
     "create a call to `import`" in {
-      val List(callToImport) = cpg.call("import").l
+      val List(callToImport) = cpg.call(Operators.importCall).l
       callToImport.code shouldBe "from foo import Bar"
       val List(where, what) = callToImport.argument.l
       where.code shouldBe "foo"
       what.code shouldBe "Bar"
     }
 
     "create an assignment with the import on the right-hand-side" in {
-      val List(assignment) = cpg.call("import").inAssignment.l
+      val List(assignment) = cpg.call(Operators.importCall).inAssignment.l
       assignment.target.code shouldBe "Bar"
       assignment.source.code shouldBe "from foo import Bar"
     }
@@ -84,7 +85,7 @@ class ImportsPassTests extends PySrc2CpgFixture(withOssDataflow = false) {
   "For an import of a module with alias, it" should {
     lazy val cpg = code("import foo as bar")
     "create a call to `import`" in {
-      val List(callToImport) = cpg.call("import").l
+      val List(callToImport) = cpg.call(Operators.importCall).l
       callToImport.code shouldBe "import foo as bar"
       val List(where, what, as) = callToImport.argument.l
       where.code shouldBe ""
@@ -93,7 +94,7 @@ class ImportsPassTests extends PySrc2CpgFixture(withOssDataflow = false) {
     }
 
     "create an assignment with the import on the right-hand-side" in {
-      val List(assignment) = cpg.call("import").inAssignment.l
+      val List(assignment) = cpg.call(Operators.importCall).inAssignment.l
       assignment.target.code shouldBe "bar"
       assignment.source.code shouldBe "import foo as bar"
     }
@@ -109,7 +110,7 @@ class ImportsPassTests extends PySrc2CpgFixture(withOssDataflow = false) {
   "For an import of a class by alias, it" should {
     lazy val cpg = code("from foo import Bar as Woo")
     "create a call to `import`" in {
-      val List(callToImport) = cpg.call("import").l
+      val List(callToImport) = cpg.call(Operators.importCall).l
       callToImport.code shouldBe "from foo import Bar as Woo"
       val List(where, what, as) = callToImport.argument.l
       where.code shouldBe "foo"
@@ -118,7 +119,7 @@ class ImportsPassTests extends PySrc2CpgFixture(withOssDataflow = false) {
     }
 
     "create an assignment with the import on the right-hand-side" in {
-      val List(assignment) = cpg.call("import").inAssignment.l
+      val List(assignment) = cpg.call(Operators.importCall).inAssignment.l
       assignment.target.code shouldBe "Woo"
       assignment.source.code shouldBe "from foo import Bar as Woo"
     }

joern-cli/frontends/pysrc2cpg/src/test/scala/io/joern/pysrc2cpg/passes/TypeRecoveryPassTests.scala

@@ -2,6 +2,7 @@ package io.joern.pysrc2cpg.passes
 
 import io.joern.pysrc2cpg.testfixtures.PySrc2CpgFixture
 import io.joern.x2cpg.passes.frontend.XTypeHintCallLinker
+import io.shiftleft.codepropertygraph.generated.Operators
 import io.shiftleft.codepropertygraph.generated.nodes.{Call, Identifier}
 import io.shiftleft.semanticcpg.language.*
 import io.shiftleft.semanticcpg.language.importresolver.*
@@ -1325,7 +1326,8 @@ class TypeRecoveryPassTests extends PySrc2CpgFixture(withOssDataflow = false) {
         .l
       val appIncludeRouterCalls = variables.invokingCalls.nameExact("include_router")
       val includedRouters       = appIncludeRouterCalls.argument.argumentIndexGte(1).moduleVariables
-      val definitionsOfRouters  = includedRouters.definitions.whereNot(_.source.isCall.nameExact("import"))
+      val definitionsOfRouters =
+        includedRouters.definitions.whereNot(_.source.isCall.nameExact(Operators.importCall))
       val List(adminRouter, normalRouter, itemsRouter) =
         definitionsOfRouters.map(x => (x.code, x.method.fullName)).sortBy(_._1).l: @unchecked
 

joern-cli/frontends/x2cpg/src/main/scala/io/joern/x2cpg/frontendspecific/pysrc2cpg/ImportsPass.scala

@@ -1,14 +1,14 @@
 package io.joern.x2cpg.frontendspecific.pysrc2cpg
 
 import io.joern.x2cpg.passes.frontend.XImportsPass
-import io.shiftleft.codepropertygraph.generated.Cpg
+import io.shiftleft.codepropertygraph.generated.{Cpg, Operators}
 import io.shiftleft.codepropertygraph.generated.nodes.*
 import io.shiftleft.semanticcpg.language.*
 import io.shiftleft.semanticcpg.language.operatorextension.OpNodes.Assignment
 
 class ImportsPass(cpg: Cpg) extends XImportsPass(cpg) {
 
-  override protected val importCallName: String = "import"
+  override protected val importCallName: String = Operators.importCall
 
   override protected def importCallToPart(x: Call): Iterator[(Call, Assignment)] = x.inAssignment.map(y => (x, y))
 

joern-cli/frontends/x2cpg/src/main/scala/io/joern/x2cpg/frontendspecific/pysrc2cpg/PythonTypeRecovery.scala

@@ -115,8 +115,8 @@ private class RecoverForPythonFile(cpg: Cpg, cu: File, builder: DiffGraphBuilder
   }
 
   override def visitIdentifierAssignedToCall(i: Identifier, c: Call): Set[String] = {
-    // Ignore legacy import representation
-    if (c.name.equals("import")) Set.empty
+    // Ignore the import call representation
+    if (c.name.equals(Operators.importCall)) Set.empty
     // Stop custom annotation representation from hitting superclass
     else if (c.name.isBlank) Set.empty
     else super.visitIdentifierAssignedToCall(i, c)

joern-cli/src/universal/schema-extender/build.sbt

@@ -1,6 +1,6 @@
 name := "schema-extender"
 
-ThisBuild / scalaVersion := "3.7.4"
+ThisBuild / scalaVersion := "3.8.3"
 
 val cpgVersion = IO.read(file("cpg-version"))