Cleanup and speed-up of type resolution

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

@@ -31,10 +31,12 @@
 import de.fraunhofer.aisec.cpg.graph.scopes.*
 import de.fraunhofer.aisec.cpg.graph.statements.*
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.*
+import de.fraunhofer.aisec.cpg.graph.types.DeclaresType
 import de.fraunhofer.aisec.cpg.graph.types.FunctionPointerType
 import de.fraunhofer.aisec.cpg.graph.types.IncompleteType
 import de.fraunhofer.aisec.cpg.graph.types.Type
 import de.fraunhofer.aisec.cpg.helpers.Util
+import de.fraunhofer.aisec.cpg.passes.ResolveCallExpressionAmbiguityPass
 import de.fraunhofer.aisec.cpg.sarif.PhysicalLocation
 import java.util.*
 import java.util.function.Predicate
@@ -1004,6 +1006,56 @@
 
         return list
     }
+
+    /**
+     * This function tries to look up the symbol contained in [name] (using [findSymbols]) and
+     * returns a [DeclaresType] node, if this name resolved to something which declares a type.
+     */
+    fun findTypeDeclaration(name: Name, startScope: Scope?): DeclaresType? {
+        var symbols =
+            findSymbols(name = name, startScope = startScope) { it is DeclaresType }
+                .filterIsInstance<DeclaresType>()
+
+        // We need to have a single match, otherwise we have an ambiguous type, and we cannot
+        // normalize it.
+        if (symbols.size > 1) {
+            LOGGER.warn(
+                "Lookup of type {} returned more than one symbol which declares a type, this is an ambiguity and the following analysis might not be correct.",
+                name
+            )
+        }
+
+        return symbols.singleOrNull()
+    }
+
+    /**
+     * This function checks, whether there exists a [Type] for the given combination of a [name] and
+     * [scope] and returns it. It returns null, if no such type exists.
+     *
+     * This is needed in passes that need to replace potential identifiers with [Type] nodes,
+     * because of ambiguities (e.g. [ResolveCallExpressionAmbiguityPass]).
+     */
+    fun findTypeWithNameAndScope(
+        name: Name,
+        language: Language<*>?,
+        scope: Scope? = currentScope
+    ): Type? {
+        // First, check if it is a simple type
+        var type = language?.getSimpleTypeOf(name)
+        if (type != null) {
+            return type
+        }
+
+        // This could also be a typedef
+        type = typedefFor(name, scope)
+        if (type != null) {
+            return type
+        }
+
+        // Otherwise, try to find a type declaration with the given combination of symbol and name
+        var declares = findTypeDeclaration(name, scope)
+        return declares?.declaredType
+    }
 }
 
 /**

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

@@ -309,17 +309,22 @@ private constructor(
         // We want to merge everything into the final scope manager of the result
         globalCtx.scopeManager.mergeFrom(parallelContexts.map { it.scopeManager })
 
+        var b =
+            Benchmark(TranslationManager::class.java, "Updating global scopes in all types", true)
         // We also need to update all types that point to one of the "old" global scopes
         // TODO(oxisto): This is really messy and instead we should have ONE global scope
         //  and individual file scopes beneath it
         var newGlobalScope = globalCtx.scopeManager.globalScope
         var types =
-            globalCtx.typeManager.firstOrderTypes.union(globalCtx.typeManager.secondOrderTypes)
+            globalCtx.typeManager.firstOrderTypesMap.values
+                .flatten()
+                .union(globalCtx.typeManager.secondOrderTypes)
         types.forEach {
             if (it.scope is GlobalScope) {
                 it.scope = newGlobalScope
             }
         }
+        b.stop()
 
         log.info("Parallel parsing completed")
 

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

@@ -54,7 +54,16 @@ class TypeManager {
         MutableMap<TemplateDeclaration, MutableList<ParameterizedType>> =
         ConcurrentHashMap()
 
-    val firstOrderTypes: MutableSet<Type> = ConcurrentHashMap.newKeySet()
+    /**
+     * A map that contains all first order types organized by their type name as key. This is
+     * extremely helpful for retrieving all possibly types for a given type name, which is done
+     * often during frontend parsing and symbol resolving.
+     */
+    val firstOrderTypesMap = ConcurrentHashMap<String, MutableList<Type>>()
+
+    /** Retrieves the list of all *resolved* first order types. */
+    val resolvedFirstOrderTypes: MutableSet<Type> = mutableSetOf()
+
     val secondOrderTypes: MutableSet<Type> = ConcurrentHashMap.newKeySet()
 
     /**
@@ -197,9 +206,13 @@ class TypeManager {
         }
 
         if (t.isFirstOrderType) {
+            var types =
+                firstOrderTypesMap.computeIfAbsent(t.name.toString()) {
+                    Collections.synchronizedList(mutableListOf())
+                }
             // Make sure we only ever return one unique object per type
-            if (!firstOrderTypes.add(t)) {
-                return firstOrderTypes.first { it == t && it is T } as T
+            if (!types.add(t)) {
+                return types.first { it == t && it is T } as T
             } else {
                 log.trace(
                     "Registering unique first order type {}{}",
@@ -222,9 +235,9 @@ class TypeManager {
         return t
     }
 
-    /** Checks, whether a [Type] with the given [name] exists. */
-    fun typeExists(name: CharSequence): Boolean {
-        return firstOrderTypes.any { type: Type -> type.root.name == name }
+    /** Checks, whether a resolved [Type] with the given [name] exists. */
+    fun resolvedTypeExists(name: CharSequence): Boolean {
+        return resolvedFirstOrderTypes.any { type: Type -> type.name == name }
     }
 
     fun resolvePossibleTypedef(alias: Type, scopeManager: ScopeManager): Type {
@@ -235,7 +248,7 @@ class TypeManager {
 
     /**
      * This function returns the first (there should be only one) [Type] with the given [fqn] that
-     * is [Type.Origin.RESOLVED].
+     * is [Type.ResolutionState.RESOLVED].
      */
     fun lookupResolvedType(
         fqn: CharSequence,
@@ -247,16 +260,29 @@ class TypeManager {
             return primitiveType
         }
 
-        return firstOrderTypes.firstOrNull {
-            (it.typeOrigin == Type.Origin.RESOLVED || it.typeOrigin == Type.Origin.GUESSED) &&
-                it.root.name == fqn &&
+        return resolvedFirstOrderTypes.firstOrNull {
+            it.root.name == fqn &&
                 if (generics != null) {
                     (it as? ObjectType)?.generics == generics
                 } else {
                     true
                 }
         }
     }
+
+    /**
+     * This function marks a type as [Type.ResolutionState.RESOLVED] and adds it to the
+     * [resolvedFirstOrderTypes].
+     */
+    fun markAsResolved(type: Type) {
+        // Mark it as RESOLVED
+        type.resolutionState = Type.ResolutionState.RESOLVED
+
+        if (type.isFirstOrderType) {
+            // Add it to our resolved first order type list
+            resolvedFirstOrderTypes += type
+        }
+    }
 }
 
 val Type.ancestors: Set<Type.Ancestor>

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

@@ -123,6 +123,15 @@ interface HasSuperClasses : LanguageTrait {
     ): Boolean
 }
 
+/**
+ * A language trait, that specifies that this language has support for implicit receiver, e.g., that
+ * one can omit references to a base such as `this`.
+ */
+interface HasImplicitReceiver : LanguageTrait {
+
+    val receiverName: String
+}
+
 /**
  * A language trait, that specifies that this language has certain qualifiers. If so, we should
  * consider them when parsing the types.

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

@@ -115,10 +115,10 @@ fun LanguageProvider.objectType(
 
     val scope = c.scopeManager.currentScope
 
-    synchronized(c.typeManager.firstOrderTypes) {
-        // We can try to look up the type by its name and return it, if it already exists.
+    var list = c.typeManager.firstOrderTypesMap[name.toString()]
+    if (list != null) {
         var type =
-            c.typeManager.firstOrderTypes.firstOrNull {
+            list.firstOrNull {
                 it is ObjectType &&
                     it.name == name &&
                     it.scope == scope &&
@@ -128,19 +128,19 @@ fun LanguageProvider.objectType(
         if (type != null) {
             return type
         }
-
-        // Otherwise, we either need to create the type because of the generics or because we do not
-        // know the type yet.
-        type = ObjectType(name, generics, false, language)
-        // Apply our usual metadata, such as scope, code, location, if we have any. Make sure only
-        // to refer by the local name because we will treat types as sort of references when
-        // creating them and resolve them later.
-        type.applyMetadata(this, name, rawNode = rawNode, localNameOnly = true)
-
-        // Piping it through register type will ensure that in any case we return the one unique
-        // type object (per scope) for it.
-        return c.typeManager.registerType(type)
     }
+
+    // Otherwise, we either need to create the type because of the generics or because we do not
+    // know the type yet.
+    var type = ObjectType(name, generics, false, language)
+    // Apply our usual metadata, such as scope, code, location, if we have any. Make sure only
+    // to refer by the local name because we will treat types as sort of references when
+    // creating them and resolve them later.
+    type.applyMetadata(this, name, rawNode = rawNode, localNameOnly = true)
+
+    // Piping it through register type will ensure that in any case we return the one unique
+    // type object (per scope) for it.
+    return c.typeManager.registerType(type)
 }
 
 /**

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

@@ -89,7 +89,7 @@
             .appendSuper(super.toString())
             .append("parameters", parameters)
             .append("returnType", returnType)
-            .append("typeOrigin", typeOrigin)
+            .append("resolutionState", resolutionState)
             .toString()
     }
 }

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

@@ -38,7 +38,7 @@ open class NumericType(
 
     init {
         // Built-in types are always resolved
-        this.typeOrigin = Origin.RESOLVED
+        this.resolutionState = ResolutionState.RESOLVED
     }
 
     /**

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

@@ -81,7 +81,7 @@
             .appendSuper(super.toString())
             .append("elementType", elementType)
             .append("name", name)
-            .append("typeOrigin", typeOrigin)
+            .append("resolutionState", resolutionState)
             .toString()
     }
 }

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

@@ -35,6 +35,6 @@ class StringType(
 
     init {
         // Built-in types are always resolved
-        this.typeOrigin = Origin.RESOLVED
+        this.resolutionState = ResolutionState.RESOLVED
     }
 }

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

@@ -73,7 +73,7 @@
     var isPrimitive = false
         protected set
 
-    open var typeOrigin: Origin? = null
+    open var resolutionState: ResolutionState? = null
 
     /**
      * This points to the [DeclaresType] node (most likely a [Declaration]), that declares this
@@ -87,12 +87,12 @@
 
     constructor(typeName: String?) {
         name = language.parseName(typeName ?: UNKNOWN_TYPE_STRING)
-        typeOrigin = Origin.UNRESOLVED
+        resolutionState = ResolutionState.UNRESOLVED
     }
 
     constructor(type: Type?) {
         type?.name?.let { name = it.clone() }
-        typeOrigin = type?.typeOrigin
+        resolutionState = type?.resolutionState
     }
 
     constructor(typeName: CharSequence, language: Language<*>?) {
@@ -103,20 +103,33 @@
                 language.parseName(typeName)
             }
         this.language = language
-        typeOrigin = Origin.UNRESOLVED
+        resolutionState = ResolutionState.UNRESOLVED
     }
 
     constructor(fullTypeName: Name, language: Language<*>?) {
         name = fullTypeName.clone()
-        typeOrigin = Origin.UNRESOLVED
+        resolutionState = ResolutionState.UNRESOLVED
         this.language = language
     }
 
-    /** Type Origin describes where the Type information came from */
-    enum class Origin {
+    /** Information about the resolution state of this type. */
+    enum class ResolutionState {
+        /**
+         * The type is fully resolved and if it is an [ObjectType], the property
+         * [ObjectType.recordDeclaration] will have the information about where the type was
+         * declared.
+         */
         RESOLVED,
-        DATAFLOW,
-        GUESSED,
+
+        /**
+         * GUESSED is not really used anymore, except in the java frontend, which needs a more or
+         * less complete type-rewrite. Once that is done, we can remove the GUESSED state.
+         */
+        @Deprecated(message = "Use UNRESOLVED instead") GUESSED,
+
+        /**
+         * The type is not yet resolved. Therefore the type is only valid within the current scope.
+         */
         UNRESOLVED
     }
 
@@ -129,11 +142,9 @@
      * @param pointer Reason for the reference (array of pointer)
      * @return Returns a reference to the current Type. E.g. when creating a pointer to an existing
      *   ObjectType
-     *
-     * TODO(oxisto) Ideally, we would make this function "internal", but there is a bug in the Go
-     *   frontend, so that we still need this function :(
      */
-    abstract fun reference(pointer: PointerOrigin?): Type
+    // TODO(oxisto): Make this internal, but some tests still use it
+    /*internal*/ abstract fun reference(pointer: PointerOrigin?): Type
 
     /**
      * @return Dereferences the current Type by resolving the reference. E.g. when dereferencing a

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

@@ -64,7 +64,7 @@ class UnknownType private constructor() : Type() {
         return "UNKNOWN"
     }
 
-    override var typeOrigin: Origin? = null
+    override var resolutionState: ResolutionState? = null
 
     companion object {
         /** A map of [UnknownType] and their respective [Language]. */