Make the translation context available everywhere

Author: oxisto

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/ScopeManager.kt

@@ -881,9 +881,8 @@ class ScopeManager : ScopeProvider {
     ): TranslationUnitDeclaration? {
         // TODO(oxisto): This workaround is needed because it seems that not all types have a proper
         //  context :(. In this case we need to fall back to the global scope's astNode, which can
-        // be
-        //  error-prone in a multi-language scenario.
-        return if (source.ctx == null) {
+        //  be error-prone in a multi-language scenario.
+        return if (!source.isInitialized) {
             globalScope?.astNode as? TranslationUnitDeclaration
         } else {
             source.language.translationUnitForInference<TypeToInfer>(source)

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/TranslationResult.kt

@@ -93,10 +93,7 @@ class TranslationResult(
     val isCancelled: Boolean
         get() = translationManager.isCancelled()
 
-    override var ctx: TranslationContext? = null
-        get() {
-            return finalCtx
-        }
+    override var ctx: TranslationContext = finalCtx
 
     /**
      * Checks if only a single software component has been analyzed and returns its translation

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/Language.kt

@@ -340,7 +340,7 @@ abstract class Language<T : LanguageFrontend<*, *>> : Node() {
                     null,
                     source,
                     false,
-                    source.ctx!!,
+                    source.ctx,
                     null,
                     needsExactMatch = true,
                 )
@@ -416,7 +416,7 @@ abstract class Language<T : LanguageFrontend<*, *>> : Node() {
      * @param source the source that was responsible for the inference
      */
     fun <TypeToInfer : Node> translationUnitForInference(source: Node): TranslationUnitDeclaration {
-        val tu = source.ctx?.currentComponent?.translationUnits?.firstOrNull()
+        val tu = source.ctx.currentComponent?.translationUnits?.firstOrNull()
         if (tu == null) {
             throw TranslationException(
                 "No translation unit found that should be used for inference"

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/Component.kt

@@ -73,7 +73,7 @@ open class Component : Node() {
     @DoNotPersist
     val topLevel: File?
         get() {
-            return ctx?.config?.topLevels?.get(this.name.localName)
+            return ctx.config.topLevels[this.name.localName]
         }
 
     /**

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/Node.kt

@@ -76,8 +76,18 @@ abstract class Node :
      * to managers such as the [TypeManager] instance which is responsible for this particular node.
      * All managers are bundled in [TranslationContext]. It is set in [Node.applyMetadata] when a
      * [ContextProvider] is provided.
+     *
+     * Note: We EXPECT that this property is set before any other property is accessed and therefore
+     * this is a lateinit variable. In the past this was a nullable variable, and we had many null
+     * checks in the code, which then threw exceptions somewhere late in the analysis. Now, the
+     * program will abort sooner if the context is not set correctly.
+     *
+     * In the future, we might re-structure our node system and make this a constructor parameter.
      */
-    @get:JsonIgnore @Transient override var ctx: TranslationContext? = null
+    @get:JsonIgnore @Transient override lateinit var ctx: TranslationContext
+
+    val isInitialized: Boolean
+        get() = this::ctx.isInitialized
 
     /** This property holds the full name using our new [Name] class. */
     @Convert(NameConverter::class) override var name: Name = Name(EMPTY_NAME)
@@ -376,8 +386,8 @@ abstract class Node :
  */
 inline fun <reified T : Node> T.applyWithScope(block: T.() -> Unit): T {
     return this.apply {
-        ctx?.scopeManager?.enterScope(this)
+        ctx.scopeManager.enterScope(this)
         block()
-        ctx?.scopeManager?.leaveScope(this)
+        ctx.scopeManager.leaveScope(this)
     }
 }

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/NodeBuilder.kt

@@ -378,7 +378,7 @@ private fun <AstNode> Node.setCodeAndLocation(
     provider: CodeAndLocationProvider<AstNode>,
     rawNode: AstNode,
 ) {
-    if (this.ctx?.config?.codeInNodes == true) {
+    if (this.ctx.config.codeInNodes == true) {
         // only set code, if it's not already set or empty
         val code = provider.codeOf(rawNode)
         if (code != null) {

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/types/FunctionType.kt

@@ -26,7 +26,6 @@
 package de.fraunhofer.aisec.cpg.graph.types
 
 import de.fraunhofer.aisec.cpg.frontends.Language
-import de.fraunhofer.aisec.cpg.frontends.TranslationException
 import de.fraunhofer.aisec.cpg.graph.declarations.FunctionDeclaration
 import de.fraunhofer.aisec.cpg.graph.unknownType
 
@@ -73,8 +72,7 @@ constructor(
                     func.language,
                 )
 
-            val c = func.ctx ?: throw TranslationException("context not available")
-            return c.typeManager.registerType(type)
+            return func.ctx.typeManager.registerType(type)
         }
     }
 }

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/passes/inference/DFGFunctionSummaries.kt

@@ -117,7 +117,7 @@ class DFGFunctionSummaries {
         val language = functionDecl.language
         val languageName = language.javaClass.name
         val methodName = functionDecl.name
-        val typeManager = functionDecl.ctx?.typeManager ?: return null
+        val typeManager = functionDecl.ctx.typeManager
 
         // The language and the method name have to match. If a signature is specified, it also has
         // to match to the one of the FunctionDeclaration, null indicates that we accept everything.

cpg-core/src/test/kotlin/de/fraunhofer/aisec/cpg/enhancements/DFGFunctionSummariesTest.kt

@@ -88,32 +88,25 @@ class DFGFunctionSummariesTest {
                                 // We need three types with a type hierarchy.
                                 val objectType = t("test.Object")
                                 val listType = t("test.List")
-                                ctx?.let {
-                                    val recordDecl =
-                                        startInference(it)?.inferRecordDeclaration(listType)
-                                    listType.recordDeclaration = recordDecl
-                                    recordDecl?.addSuperClass(objectType)
-                                    listType.superTypes.add(objectType)
-                                }
+                                var recordDecl =
+                                    startInference(ctx)?.inferRecordDeclaration(listType)
+                                listType.recordDeclaration = recordDecl
+                                recordDecl?.addSuperClass(objectType)
+                                listType.superTypes.add(objectType)
 
                                 val specialListType = t("test.SpecialList")
-                                ctx?.let {
-                                    val recordDecl =
-                                        startInference(it)?.inferRecordDeclaration(specialListType)
-                                    specialListType.recordDeclaration = recordDecl
-                                    recordDecl?.addSuperClass(listType)
-                                    specialListType.superTypes.add(listType)
-                                }
+                                recordDecl =
+                                    startInference(ctx)?.inferRecordDeclaration(specialListType)
+                                specialListType.recordDeclaration = recordDecl
+                                recordDecl?.addSuperClass(listType)
+                                specialListType.superTypes.add(listType)
 
                                 val verySpecialListType = t("test.VerySpecialList")
-                                ctx?.let {
-                                    val recordDecl =
-                                        startInference(it)
-                                            ?.inferRecordDeclaration(verySpecialListType)
-                                    verySpecialListType.recordDeclaration = recordDecl
-                                    recordDecl?.addSuperClass(specialListType)
-                                    verySpecialListType.superTypes.add(listType)
-                                }
+                                recordDecl =
+                                    startInference(ctx)?.inferRecordDeclaration(verySpecialListType)
+                                verySpecialListType.recordDeclaration = recordDecl
+                                recordDecl?.addSuperClass(specialListType)
+                                verySpecialListType.superTypes.add(listType)
                             }
 
                             function("main", t("int")) {

cpg-core/src/test/kotlin/de/fraunhofer/aisec/cpg/graph/ExpressionBuilderTest.kt

@@ -25,50 +25,53 @@
  */
 package de.fraunhofer.aisec.cpg.graph
 
+import de.fraunhofer.aisec.cpg.frontends.TestLanguageFrontend
 import de.fraunhofer.aisec.cpg.graph.builder.plus
 import de.fraunhofer.aisec.cpg.graph.declarations.FieldDeclaration
 import de.fraunhofer.aisec.cpg.graph.edges.flows.CallingContextIn
 import de.fraunhofer.aisec.cpg.graph.edges.flows.ContextSensitiveDataflow
 import de.fraunhofer.aisec.cpg.graph.edges.flows.PartialDataflowGranularity
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.CallExpression
-import de.fraunhofer.aisec.cpg.graph.statements.expressions.Literal
-import de.fraunhofer.aisec.cpg.graph.statements.expressions.Reference
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 class ExpressionBuilderTest {
     @Test
     fun testDuplicateWithDFGProperties() {
-        val node1 = Literal<Int>()
-        val node2 = Reference()
-        val granularity = PartialDataflowGranularity(FieldDeclaration())
-        val callingContextIn = CallingContextIn(CallExpression())
-        node1.prevDFGEdges.addContextSensitive(node2, granularity, callingContextIn)
+        with(TestLanguageFrontend()) {
+            val node1 = newLiteral(42)
+            val node2 = newReference("foo")
+            val granularity = PartialDataflowGranularity(FieldDeclaration())
+            val callingContextIn = CallingContextIn(CallExpression())
+            node1.prevDFGEdges.addContextSensitive(node2, granularity, callingContextIn)
 
-        val clone = node1.duplicate(false)
-        val clonedPrevDFG = clone.prevDFGEdges.single()
-        assertTrue(clonedPrevDFG is ContextSensitiveDataflow)
-        assertEquals(callingContextIn, clonedPrevDFG.callingContext)
-        assertEquals(granularity, clonedPrevDFG.granularity)
+            val clone = node1.duplicate(false)
+            val clonedPrevDFG = clone.prevDFGEdges.single()
+            assertTrue(clonedPrevDFG is ContextSensitiveDataflow)
+            assertEquals(callingContextIn, clonedPrevDFG.callingContext)
+            assertEquals(granularity, clonedPrevDFG.granularity)
 
-        assertEquals(setOf<Node>(node1, clone), node2.nextDFG)
+            assertEquals(setOf<Node>(node1, clone), node2.nextDFG)
+        }
     }
 
     @Test
     fun testDuplicateWithDFGProperties2() {
-        val node1 = Literal<Int>()
-        val node2 = Reference()
-        val granularity = PartialDataflowGranularity(FieldDeclaration())
-        val callingContextIn = CallingContextIn(CallExpression())
-        node1.nextDFGEdges.addContextSensitive(node2, granularity, callingContextIn)
+        with(TestLanguageFrontend()) {
+            val node1 = newLiteral(42)
+            val node2 = newReference("foo")
+            val granularity = PartialDataflowGranularity(FieldDeclaration())
+            val callingContextIn = CallingContextIn(CallExpression())
+            node1.nextDFGEdges.addContextSensitive(node2, granularity, callingContextIn)
 
-        val clone = node1.duplicate(false)
-        val clonedPrevDFG = clone.nextDFGEdges.single()
-        assertTrue(clonedPrevDFG is ContextSensitiveDataflow)
-        assertEquals(callingContextIn, clonedPrevDFG.callingContext)
-        assertEquals(granularity, clonedPrevDFG.granularity)
+            val clone = node1.duplicate(false)
+            val clonedPrevDFG = clone.nextDFGEdges.single()
+            assertTrue(clonedPrevDFG is ContextSensitiveDataflow)
+            assertEquals(callingContextIn, clonedPrevDFG.callingContext)
+            assertEquals(granularity, clonedPrevDFG.granularity)
 
-        assertEquals(setOf<Node>(node1, clone), node2.prevDFG)
+            assertEquals(setOf<Node>(node1, clone), node2.prevDFG)
+        }
     }
 }

cpg-language-cxx/src/test/kotlin/de/fraunhofer/aisec/cpg/enhancements/types/TypedefTest.kt

@@ -82,7 +82,7 @@ internal class TypedefTest : BaseTest() {
             assertEquals(NumericType.Modifier.UNSIGNED, returnType.modifier)
             assertEquals(uintfp1.type, uintfp2?.type)
 
-            val type = tu.ctx?.scopeManager?.typedefFor(Name("test"))
+            val type = tu.ctx.scopeManager.typedefFor(Name("test"))
             assertIs<IntegerType>(type)
             assertLocalName("uint8_t", type)
         }
@@ -161,7 +161,7 @@ internal class TypedefTest : BaseTest() {
             val fPtr2 = tu.variables["intFptr2"]
             assertEquals(fPtr1?.type, fPtr2?.type)
 
-            val type = tu.ctx?.scopeManager?.typedefFor(Name("type_B"))
+            val type = tu.ctx.scopeManager.typedefFor(Name("type_B"))
             assertLocalName("template_class_A", type)
             assertIs<ObjectType>(type)
             assertEquals(listOf(primitiveType("int"), primitiveType("int")), type.generics)

cpg-language-cxx/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/cxx/CXXLanguageFrontendTest.kt

@@ -1408,7 +1408,7 @@ internal class CXXLanguageFrontendTest : BaseTest() {
                 it.registerLanguage<CLanguage>()
             }
         with(tu) {
-            val typedefs = tu.ctx?.scopeManager?.typedefFor(Name("MyStruct"))
+            val typedefs = tu.ctx.scopeManager.typedefFor(Name("MyStruct"))
             assertLocalName("__myStruct", typedefs)
 
             val main = tu.functions["main"]

cpg-language-java/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/java/JavaCallResolverHelper.kt

@@ -110,7 +110,7 @@ class JavaCallResolverHelper {
             val baseName = callee.base.name.parent ?: return null
 
             val type =
-                callee.ctx?.typeManager?.lookupResolvedType(baseName.toString())
+                callee.ctx.typeManager.lookupResolvedType(baseName.toString())
                     ?: callee.unknownType()
             if (type in curClass.implementedInterfaces) {
                 // Basename is an interface -> BaseName.super refers to BaseName itself

cpg-neo4j/src/main/kotlin/de/fraunhofer/aisec/cpg_vis_neo4j/Application.kt

@@ -490,6 +490,7 @@ class Application : Callable<Int> {
             val pieces = customPasses.split(",")
             for (pass in pieces) {
                 if (pass.contains(".")) {
+                    @Suppress("UNCHECKED_CAST")
                     translationConfiguration.registerPass(
                         Class.forName(pass).kotlin as KClass<out Pass<*>>
                     )