[TypeRecovery] Re-work for Fixed Iteration Strategy & Using POSSIBLE_TYPES

console/src/main/scala/io/joern/console/cpgcreation/PythonSrcCpgGenerator.scala

@@ -5,7 +5,7 @@ import io.joern.pysrc2cpg.*
 import io.joern.x2cpg.X2Cpg
 import io.joern.x2cpg.passes.base.AstLinkerPass
 import io.joern.x2cpg.passes.callgraph.NaiveCallLinker
-import io.joern.x2cpg.passes.frontend.XTypeRecoveryConfig
+import io.joern.x2cpg.passes.frontend.TypeRecoveryConfig
 import io.shiftleft.codepropertygraph.Cpg
 
 import java.nio.file.Path
@@ -32,8 +32,8 @@ case class PythonSrcCpgGenerator(config: FrontendConfig, rootPath: Path) extends
     new DynamicTypeHintFullNamePass(cpg).createAndApply()
     new PythonInheritanceNamePass(cpg).createAndApply()
     val typeRecoveryConfig = pyConfig match
-      case Some(config) => XTypeRecoveryConfig(config.typePropagationIterations, !config.disableDummyTypes)
-      case None         => XTypeRecoveryConfig()
+      case Some(config) => TypeRecoveryConfig(config.typePropagationIterations, !config.disableDummyTypes)
+      case None         => TypeRecoveryConfig()
     new PythonTypeRecoveryPass(cpg, typeRecoveryConfig).createAndApply()
     new PythonTypeHintCallLinker(cpg).createAndApply()
     new NaiveCallLinker(cpg).createAndApply()

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/JavaSrc2Cpg.scala

@@ -9,7 +9,7 @@ import io.joern.javasrc2cpg.passes.{
   TypeInferencePass
 }
 import io.joern.x2cpg.X2Cpg.withNewEmptyCpg
-import io.joern.x2cpg.passes.frontend.{MetaDataPass, TypeNodePass, XTypeRecoveryConfig}
+import io.joern.x2cpg.passes.frontend.{MetaDataPass, TypeNodePass, TypeRecoveryConfig}
 import io.joern.x2cpg.X2CpgFrontend
 import io.shiftleft.codepropertygraph.Cpg
 import io.shiftleft.codepropertygraph.generated.Languages
@@ -57,7 +57,7 @@ object JavaSrc2Cpg {
 
   def typeRecoveryPasses(cpg: Cpg, config: Option[Config] = None): List[CpgPassBase] = {
     List(
-      new JavaTypeRecoveryPass(cpg, XTypeRecoveryConfig(enabledDummyTypes = !config.exists(_.disableDummyTypes))),
+      new JavaTypeRecoveryPass(cpg, TypeRecoveryConfig(enabledDummyTypes = !config.exists(_.disableDummyTypes))),
       new JavaTypeHintCallLinker(cpg)
     )
   }

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/passes/AstCreationPass.scala

@@ -21,7 +21,7 @@ import io.joern.javasrc2cpg.util.{Delombok, SourceParser}
 import io.joern.javasrc2cpg.{Config, JavaSrc2Cpg}
 import io.joern.x2cpg.SourceFiles
 import io.joern.x2cpg.datastructures.Global
-import io.joern.x2cpg.passes.frontend.XTypeRecoveryConfig
+import io.joern.x2cpg.passes.frontend.TypeRecoveryConfig
 import io.joern.x2cpg.utils.dependency.DependencyResolver
 import io.shiftleft.codepropertygraph.Cpg
 import io.shiftleft.passes.ConcurrentWriterCpgPass

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/passes/JavaTypeRecoveryPass.scala

@@ -1,60 +1,86 @@
 package io.joern.javasrc2cpg.passes
 
 import io.joern.x2cpg.Defines
-import io.joern.x2cpg.passes.frontend._
+import io.joern.x2cpg.passes.frontend.*
+import io.joern.x2cpg.passes.frontend.ImportsPass.ResolvedImport
 import io.shiftleft.codepropertygraph.Cpg
 import io.shiftleft.codepropertygraph.generated.PropertyNames
-import io.shiftleft.codepropertygraph.generated.nodes._
-import io.shiftleft.semanticcpg.language._
+import io.shiftleft.codepropertygraph.generated.nodes.*
 import overflowdb.BatchedUpdate.DiffGraphBuilder
+import overflowdb.traversal.ImplicitsTmp.toTraversalSugarExt
 
-class JavaTypeRecoveryPass(cpg: Cpg, config: XTypeRecoveryConfig = XTypeRecoveryConfig())
-    extends XTypeRecoveryPass[Method](cpg, config) {
-  override protected def generateRecoveryPass(state: XTypeRecoveryState): XTypeRecovery[Method] =
-    new JavaTypeRecovery(cpg, state)
-}
-
-private class JavaTypeRecovery(cpg: Cpg, state: XTypeRecoveryState) extends XTypeRecovery[Method](cpg, state) {
-
-  override def compilationUnit: Iterator[Method] = cpg.method.isExternal(false).iterator
+import java.util.concurrent.ExecutorService
 
-  override def generateRecoveryForCompilationUnitTask(
-    unit: Method,
-    builder: DiffGraphBuilder
-  ): RecoverForXCompilationUnit[Method] = {
-    val newConfig = state.config.copy(enabledDummyTypes = state.isFinalIteration && state.config.enabledDummyTypes)
-    new RecoverForJavaFile(cpg, unit, builder, state.copy(config = newConfig))
-  }
+class JavaTypeRecoveryPass(cpg: Cpg, config: TypeRecoveryConfig = TypeRecoveryConfig())
+    extends XTypeRecoveryPass(cpg, config) {
+  override protected def generateRecoveryPass(state: TypeRecoveryState, executor: ExecutorService): XTypeRecovery =
+    new JavaTypeRecovery(cpg, state, executor)
 }
 
-private class RecoverForJavaFile(cpg: Cpg, cu: Method, builder: DiffGraphBuilder, state: XTypeRecoveryState)
-    extends RecoverForXCompilationUnit[Method](cpg, cu, builder, state) {
+private class JavaTypeRecovery(cpg: Cpg, state: TypeRecoveryState, executor: ExecutorService)
+    extends XTypeRecovery(cpg, state, executor) {
+
+  override protected val initialSymbolTable = new SymbolTable[LocalKey](javaNodeToLocalKey)
 
   private def javaNodeToLocalKey(n: AstNode): Option[LocalKey] = n match {
     case i: Identifier if i.name == "this" && i.code == "super" => Option(LocalVar("super"))
     case _                                                      => SBKey.fromNodeToLocalKey(n)
   }
 
-  override protected val symbolTable = new SymbolTable[LocalKey](javaNodeToLocalKey)
+  override protected def recoverTypesForProcedure(
+    cpg: Cpg,
+    procedure: Method,
+    initialSymbolTable: SymbolTable[LocalKey],
+    builder: DiffGraphBuilder,
+    state: TypeRecoveryState
+  ): RecoverTypesForProcedure =
+    RecoverForJavaFile(cpg, procedure, initialSymbolTable, builder, state)
 
-  override protected def isConstructor(c: Call): Boolean = isConstructor(c.name)
+  override protected def importNodes(cu: File): List[ResolvedImport] =
+    cu.namespaceBlock.flatMap(_.astOut).collectAll[Import].flatMap(visitImport).l
 
-  override protected def isConstructor(name: String): Boolean = !name.isBlank && name.charAt(0).isUpper
+  // Java has a much simpler import structure that doesn't need resolution
+  override protected def visitImport(i: Import): Iterator[ImportsPass.ResolvedImport] = {
+    for {
+      alias    <- i.importedAs
+      fullName <- i.importedEntity
+    } {
+      if (alias != "*") {
+        initialSymbolTable.append(CallAlias(alias, Option("this")), fullName)
+        initialSymbolTable.append(LocalVar(alias), fullName)
+      }
+    }
+    Iterator.empty
+  }
 
   override protected def postVisitImports(): Unit = {
-    symbolTable.view.foreach { case (k, ts) =>
+    initialSymbolTable.view.foreach { case (k, ts) =>
       val tss = ts.filterNot(_.startsWith(Defines.UnresolvedNamespace))
       if (tss.isEmpty)
-        symbolTable.remove(k)
+        initialSymbolTable.remove(k)
       else
-        symbolTable.put(k, tss)
+        initialSymbolTable.put(k, tss)
     }
   }
 
+}
+
+private class RecoverForJavaFile(
+  cpg: Cpg,
+  procedure: Method,
+  symbolTable: SymbolTable[LocalKey],
+  builder: DiffGraphBuilder,
+  state: TypeRecoveryState
+) extends RecoverTypesForProcedure(cpg, procedure, symbolTable, builder, state) {
+
+  override protected def isConstructor(c: Call): Boolean = isConstructor(c.name)
+
+  override protected def isConstructor(name: String): Boolean = !name.isBlank && name.charAt(0).isUpper
+
   // There seems to be issues with inferring these, often due to situations where super and this are confused on name
   // and code properties.
   override protected def storeIdentifierTypeInfo(i: Identifier, types: Seq[String]): Unit = if (i.name != "this") {
-    super.storeIdentifierTypeInfo(i, types)
+    super.storeIdentifierTypeInfo(i, types.filterNot(_ == "null"))
   }
 
   override protected def storeCallTypeInfo(c: Call, types: Seq[String]): Unit =
@@ -64,7 +90,9 @@ private class RecoverForJavaFile(cpg: Cpg, cu: Method, builder: DiffGraphBuilder
         case t if t.endsWith(c.signature) => t
         case t                            => s"$t:${c.signature}"
       }
-      builder.setNodeProperty(c, PropertyNames.DYNAMIC_TYPE_HINT_FULL_NAME, signedTypes)
+      if (c.possibleTypes != signedTypes) {
+        builder.setNodeProperty(c, PropertyNames.POSSIBLE_TYPES, signedTypes)
+      }
     }
 
 }

joern-cli/frontends/javasrc2cpg/src/test/scala/io/joern/javasrc2cpg/querying/TypeInferenceTests.scala

@@ -354,11 +354,16 @@ class JavaTypeRecoveryPassTests extends JavaSrcCode2CpgFixture(enableTypeRecover
       Seq("net", "javaguides", "hibernate", "NamedQueryExample.java").mkString(File.separator)
     )
 
-    "should be resolved using dummy return values" in {
+    "receive a full namespace from Java inference" in {
+      val Some(getResultList) = cpg.call("createNamedQuery").headOption: @unchecked
+      getResultList.methodFullName shouldBe "org.hibernate.Session.createNamedQuery:<unresolvedSignature>(2)"
+    }
+
+    "resolve the second call using dummy return values" in {
       val Some(getResultList) = cpg.call("getResultList").headOption: @unchecked
       // Changes the below from <unresolvedNamespace>.getResultList:<unresolvedSignature>(0) to:
       getResultList.methodFullName shouldBe "org.hibernate.Session.createNamedQuery:<unresolvedSignature>(2).<returnValue>.getResultList:<unresolvedSignature>(0)"
-      getResultList.dynamicTypeHintFullName shouldBe Seq()
+      getResultList.possibleTypes shouldBe Seq()
     }
 
     "hint that `transaction` may be of the null type" in {

joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/JsSrc2Cpg.scala

@@ -8,7 +8,7 @@ import io.joern.jssrc2cpg.utils.AstGenRunner
 import io.joern.x2cpg.X2Cpg.withNewEmptyCpg
 import io.joern.x2cpg.X2CpgFrontend
 import io.joern.x2cpg.passes.callgraph.NaiveCallLinker
-import io.joern.x2cpg.passes.frontend.XTypeRecoveryConfig
+import io.joern.x2cpg.passes.frontend.TypeRecoveryConfig
 import io.joern.x2cpg.utils.{HashUtil, Report}
 import io.shiftleft.codepropertygraph.Cpg
 import io.shiftleft.passes.CpgPassBase
@@ -58,8 +58,8 @@ object JsSrc2Cpg {
 
   def postProcessingPasses(cpg: Cpg, config: Option[Config] = None): List[CpgPassBase] = {
     val typeRecoveryConfig = config
-      .map(c => XTypeRecoveryConfig(c.typePropagationIterations, !c.disableDummyTypes))
-      .getOrElse(XTypeRecoveryConfig())
+      .map(c => TypeRecoveryConfig(c.typePropagationIterations, !c.disableDummyTypes))
+      .getOrElse(TypeRecoveryConfig())
     List(
       new JavaScriptInheritanceNamePass(cpg),
       new ConstClosurePass(cpg),

joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/passes/ImportResolverPass.scala

@@ -94,9 +94,9 @@ class ImportResolverPass(cpg: Cpg) extends XImportResolverPass(cpg) {
                if (methodMatches.nonEmpty) methodMatches.fullName.toSet
                else constructorMatches.fullName.toSet
              if (methodPaths.nonEmpty) {
-               methodPaths.flatMap(x => Set(ResolvedMethod(x, alias, Option("this")), ResolvedTypeDecl(x)))
+               methodPaths.flatMap(x => Set(ResolvedMethod(x, alias, Option("this")), ResolvedTypeDecl(x, alias)))
              } else if (moduleExportsThisVariable) {
-               Set(ResolvedMember(targetModule.fullName.head, b.name))
+               Set(ResolvedMember(targetModule.fullName.head, b.name, alias))
              } else {
                Set.empty
              }
@@ -108,7 +108,7 @@ class ImportResolverPass(cpg: Cpg) extends XImportResolverPass(cpg) {
              b.referencedMethod.astParent.iterator
                .collectAll[Method]
                .fullName
-               .map(x => ResolvedTypeDecl(x))
+               .map(x => ResolvedTypeDecl(x, alias))
                .toSet ++ Set(ResolvedMethod(b.methodFullName, callName, receiver))
            case ::(_, ::(y: Call, _)) =>
              // Exported closure with a method ref within the AST of the RHS
@@ -118,7 +118,7 @@ class ImportResolverPass(cpg: Cpg) extends XImportResolverPass(cpg) {
          }
        }.toSet
      } else {
-       Set(UnknownMethod(entity, alias, Option("this")), UnknownTypeDecl(entity))
+       Set(UnknownMethod(entity, alias, Option("this")), UnknownTypeDecl(entity, alias))
      }).foreach(x => resolvedImportToTag(x, importCall, diffGraph))
   }