pysrc: use consistent type names (joernio#4329)

Privado-Inc · Mar 14, 2024 · 446b4bb · 446b4bb
1 parent d80cd61
commit 446b4bb
Show file tree

Hide file tree

Showing 5 changed files with 26 additions and 23 deletions.
diff --git a/joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/Constants.scala b/joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/Constants.scala
@@ -1,11 +1,13 @@
 package io.joern.pysrc2cpg
 
 object Constants {
+  val builtinPrefix = "__builtin."
+
   val ANY                = "ANY"
   val GLOBAL_NAMESPACE   = "<global>"
-  val builtinStrType     = "builtin.str"
-  val builtinBytesType   = "builtin.bytes"
-  val builtinIntType     = "builtin.int"
-  val builtinFloatType   = "builtin.float"
-  val builtinComplexType = "builtin.complex"
+  val builtinStrType     = s"${builtinPrefix}str"
+  val builtinBytesType   = s"${builtinPrefix}bytes"
+  val builtinIntType     = s"${builtinPrefix}int"
+  val builtinFloatType   = s"${builtinPrefix}float"
+  val builtinComplexType = s"${builtinPrefix}complex"
 }
diff --git a/joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/NodeBuilder.scala b/joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/NodeBuilder.scala
@@ -1,6 +1,7 @@
 package io.joern.pysrc2cpg
 
-import io.joern.pysrc2cpg.PythonAstVisitor.{allBuiltinClasses, builtinPrefix, typingClassesV3, typingPrefix}
+import io.joern.pysrc2cpg.PythonAstVisitor.{allBuiltinClasses, typingClassesV3, typingPrefix}
+import io.joern.pysrc2cpg.Constants.builtinPrefix
 import io.joern.pythonparser.ast
 import io.joern.x2cpg.Defines
 import io.joern.x2cpg.utils.NodeBuilders

diff --git a/joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/PythonAstVisitor.scala b/joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/PythonAstVisitor.scala
@@ -1,7 +1,8 @@
 package io.joern.pysrc2cpg
 
-import PythonAstVisitor.{builtinPrefix, logger, metaClassSuffix, noLineAndColumn}
+import PythonAstVisitor.{logger, metaClassSuffix, noLineAndColumn}
 import io.joern.pysrc2cpg.memop.*
+import io.joern.pysrc2cpg.Constants.builtinPrefix
 import io.joern.pythonparser.ast
 import io.joern.x2cpg.{AstCreatorBase, ValidationMode}
 import io.shiftleft.codepropertygraph.generated.*
@@ -2087,7 +2088,6 @@ class PythonAstVisitor(
 object PythonAstVisitor {
   private val logger = LoggerFactory.getLogger(getClass)
 
-  val builtinPrefix   = "__builtin."
   val typingPrefix    = "typing."
   val metaClassSuffix = "<meta>"
 

diff --git a/...-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/PythonTypeHintCallLinker.scala b/...-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/PythonTypeHintCallLinker.scala
@@ -22,7 +22,7 @@ class PythonTypeHintCallLinker(cpg: Cpg) extends XTypeHintCallLinker(cpg) {
       super.setCallees(call, methodNames, builder)
     } else if (methodNames.sizeIs > 1) {
       val nonDummyMethodNames =
-        methodNames.filterNot(x => isDummyType(x) || x.startsWith(PythonAstVisitor.builtinPrefix + "None"))
+        methodNames.filterNot(x => isDummyType(x) || x.startsWith(Constants.builtinPrefix + "None"))
       super.setCallees(call, nonDummyMethodNames, builder)
     }
   }

diff --git a/joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/PythonTypeRecovery.scala b/joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/PythonTypeRecovery.scala
@@ -100,11 +100,11 @@ private class RecoverForPythonFile(cpg: Cpg, cu: File, builder: DiffGraphBuilder
 
   override def visitIdentifierAssignedToOperator(i: Identifier, c: Call, operation: String): Set[String] = {
     operation match {
-      case "<operator>.listLiteral"  => associateTypes(i, Set(s"${PythonAstVisitor.builtinPrefix}list"))
-      case "<operator>.tupleLiteral" => associateTypes(i, Set(s"${PythonAstVisitor.builtinPrefix}tuple"))
-      case "<operator>.dictLiteral"  => associateTypes(i, Set(s"${PythonAstVisitor.builtinPrefix}dict"))
-      case "<operator>.setLiteral"   => associateTypes(i, Set(s"${PythonAstVisitor.builtinPrefix}set"))
-      case Operators.conditional     => associateTypes(i, Set(s"${PythonAstVisitor.builtinPrefix}bool"))
+      case "<operator>.listLiteral"  => associateTypes(i, Set(s"${Constants.builtinPrefix}list"))
+      case "<operator>.tupleLiteral" => associateTypes(i, Set(s"${Constants.builtinPrefix}tuple"))
+      case "<operator>.dictLiteral"  => associateTypes(i, Set(s"${Constants.builtinPrefix}dict"))
+      case "<operator>.setLiteral"   => associateTypes(i, Set(s"${Constants.builtinPrefix}set"))
+      case Operators.conditional     => associateTypes(i, Set(s"${Constants.builtinPrefix}bool"))
       case _                         => super.visitIdentifierAssignedToOperator(i, c, operation)
     }
   }
@@ -135,10 +135,10 @@ private class RecoverForPythonFile(cpg: Cpg, cu: File, builder: DiffGraphBuilder
   }
 
   override def getTypesFromCall(c: Call): Set[String] = c.name match {
-    case "<operator>.listLiteral"  => Set(s"${PythonAstVisitor.builtinPrefix}list")
-    case "<operator>.tupleLiteral" => Set(s"${PythonAstVisitor.builtinPrefix}tuple")
-    case "<operator>.dictLiteral"  => Set(s"${PythonAstVisitor.builtinPrefix}dict")
-    case "<operator>.setLiteral"   => Set(s"${PythonAstVisitor.builtinPrefix}set")
+    case "<operator>.listLiteral"  => Set(s"${Constants.builtinPrefix}list")
+    case "<operator>.tupleLiteral" => Set(s"${Constants.builtinPrefix}tuple")
+    case "<operator>.dictLiteral"  => Set(s"${Constants.builtinPrefix}dict")
+    case "<operator>.setLiteral"   => Set(s"${Constants.builtinPrefix}set")
     case _                         => super.getTypesFromCall(c)
   }
 
@@ -159,11 +159,11 @@ private class RecoverForPythonFile(cpg: Cpg, cu: File, builder: DiffGraphBuilder
 
   override def getLiteralType(l: Literal): Set[String] = {
     val literalTypes = (l.code match {
-      case code if code.toIntOption.isDefined                  => Some(s"${PythonAstVisitor.builtinPrefix}int")
-      case code if code.toDoubleOption.isDefined               => Some(s"${PythonAstVisitor.builtinPrefix}float")
-      case code if "True".equals(code) || "False".equals(code) => Some(s"${PythonAstVisitor.builtinPrefix}bool")
-      case code if code.equals("None")                         => Some(s"${PythonAstVisitor.builtinPrefix}None")
-      case code if isPyString(code)                            => Some(s"${PythonAstVisitor.builtinPrefix}str")
+      case code if code.toIntOption.isDefined                  => Some(s"${Constants.builtinPrefix}int")
+      case code if code.toDoubleOption.isDefined               => Some(s"${Constants.builtinPrefix}float")
+      case code if "True".equals(code) || "False".equals(code) => Some(s"${Constants.builtinPrefix}bool")
+      case code if code.equals("None")                         => Some(s"${Constants.builtinPrefix}None")
+      case code if isPyString(code)                            => Some(s"${Constants.builtinPrefix}str")
       case _                                                   => None
     }).toSet
     setTypes(l, literalTypes.toSeq)