kotlin2cpg: simplify fallback type logic

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/types/DefaultTypeInfoProvider.scala

@@ -51,7 +51,7 @@ import org.jetbrains.kotlin.resolve.{BindingContext, DescriptorToSourceUtils, De
 import org.jetbrains.kotlin.resolve.DescriptorUtils.getSuperclassDescriptors
 import org.jetbrains.kotlin.resolve.`lazy`.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
-import org.jetbrains.kotlin.types.UnresolvedType
+import org.jetbrains.kotlin.types.ErrorType
 import org.slf4j.LoggerFactory
 
 import scala.jdk.CollectionConverters.CollectionHasAsScala
@@ -185,6 +185,7 @@ class DefaultTypeInfoProvider(environment: KotlinCoreEnvironment) extends TypeIn
     val mapForEntity = bindingsForEntity(bindingContext, expr)
     Option(mapForEntity.get(BindingContext.TYPE_ALIAS.getKey))
       .map(_.getExpandedType)
+      .filterNot(_.isInstanceOf[ErrorType])
       .map(TypeRenderer.render(_))
       .filter(isValidRender)
       .getOrElse(defaultValue)
@@ -200,23 +201,18 @@ class DefaultTypeInfoProvider(environment: KotlinCoreEnvironment) extends TypeIn
 
   def propertyType(expr: KtProperty, defaultValue: String): String = {
     val mapForEntity = bindingsForEntity(bindingContext, expr)
-    val render =
-      Option(mapForEntity.get(BindingContext.VARIABLE.getKey))
-        .map(_.getType)
-        .map(TypeRenderer.render(_))
-        .filter(isValidRender)
-
-    render match {
-      case Some(value) if value == Defines.UnresolvedNamespace =>
+    Option(mapForEntity.get(BindingContext.VARIABLE.getKey))
+      .map(_.getType)
+      .filterNot(_.isInstanceOf[ErrorType])
+      .map(TypeRenderer.render(_))
+      .filter(isValidRender)
+      .getOrElse(
         Option(expr.getTypeReference)
           .map { typeRef =>
             typeFromImports(typeRef.getText, expr.getContainingKtFile).getOrElse(typeRef.getText)
           }
           .getOrElse(defaultValue)
-      case Some(aValue) => aValue
-      case None         => defaultValue
-    }
-
+      )
   }
 
   def typeFullName(expr: KtClassOrObject, defaultValue: String): String = {
@@ -514,7 +510,7 @@ class DefaultTypeInfoProvider(environment: KotlinCoreEnvironment) extends TypeIn
           extensionReceiverParam <- Option(originalDesc.getExtensionReceiverParameter)
           erpType = extensionReceiverParam.getType
         } yield {
-          if (erpType.isInstanceOf[UnresolvedType]) {
+          if (erpType.isInstanceOf[ErrorType]) {
             s"${Defines.UnresolvedNamespace}.${expr.getName}"
           } else {
             val rendered =
@@ -600,27 +596,24 @@ class DefaultTypeInfoProvider(environment: KotlinCoreEnvironment) extends TypeIn
       mapForEntity <- Option(bindingsForEntity(bindingContext, parameter))
       variableDesc <- Option(mapForEntity.get(BindingContext.VALUE_PARAMETER.getKey))
       render = TypeRenderer.render(variableDesc.getType)
-      if isValidRender(render)
+      if isValidRender(render) && !variableDesc.getType.isInstanceOf[ErrorType]
     } yield render
 
-    render match {
-      case Some(value) if value == Defines.UnresolvedNamespace =>
-        Option(parameter.getTypeReference)
-          .map { typeRef =>
-            typeFromImports(typeRef.getText, parameter.getContainingKtFile).getOrElse(typeRef.getText)
-          }
-          .getOrElse(defaultValue)
-      case Some(aValue) => aValue
-      case None         => defaultValue
-    }
+    render.getOrElse(
+      Option(parameter.getTypeReference)
+        .map { typeRef =>
+          typeFromImports(typeRef.getText, parameter.getContainingKtFile).getOrElse(typeRef.getText)
+        }
+        .getOrElse(defaultValue)
+    )
   }
 
   def destructuringEntryType(expr: KtDestructuringDeclarationEntry, defaultValue: String): String = {
     val render = for {
       mapForEntity <- Option(bindingsForEntity(bindingContext, expr))
       variableDesc <- Option(mapForEntity.get(BindingContext.VARIABLE.getKey))
       render = TypeRenderer.render(variableDesc.getType)
-      if isValidRender(render)
+      if isValidRender(render) && !variableDesc.getType.isInstanceOf[ErrorType]
     } yield render
     render.getOrElse(defaultValue)
   }
@@ -756,7 +749,7 @@ class DefaultTypeInfoProvider(environment: KotlinCoreEnvironment) extends TypeIn
       extensionReceiverParam <- Option(fnDesc.getExtensionReceiverParameter)
       erpType = extensionReceiverParam.getType
     } yield {
-      if (erpType.isInstanceOf[UnresolvedType]) {
+      if (erpType.isInstanceOf[ErrorType]) {
         s"${Defines.UnresolvedNamespace}.${expr.getName}"
       } else {
         val theType      = fnDescMaybe.get.getExtensionReceiverParameter.getType

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/types/TypeRenderer.scala

@@ -2,31 +2,19 @@ package io.joern.kotlin2cpg.types
 
 import io.joern.kotlin2cpg.psi.PsiUtils
 import io.joern.x2cpg.Defines
-import kotlin.reflect.jvm.internal.impl.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.{ClassDescriptor, DeclarationDescriptor, SimpleFunctionDescriptor}
 import org.jetbrains.kotlin.resolve.{DescriptorToSourceUtils, DescriptorUtils}
-import org.jetbrains.kotlin.types.{ErrorType, ErrorUtils, KotlinType, TypeUtils, UnresolvedType}
+import org.jetbrains.kotlin.types.{ErrorUtils, ErrorType, KotlinType, TypeProjection, TypeUtils}
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.{
-  KtCallExpression,
-  KtClassOrObject,
-  KtElement,
-  KtNamedFunction,
-  KtObjectDeclaration,
-  KtObjectLiteralExpression,
-  KtProperty
-}
 import org.jetbrains.kotlin.renderer.{DescriptorRenderer, DescriptorRendererImpl, DescriptorRendererOptionsImpl}
-import org.jetbrains.kotlin.resolve.`lazy`.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
 
-import scala.jdk.CollectionConverters._
-
 object TypeRenderer {
 
-  private val cpgUnresolvedType = ErrorUtils.createUnresolvedType(Defines.UnresolvedNamespace, List().asJava)
+  private val cpgUnresolvedType =
+    ErrorUtils.createUnresolvedType(Defines.UnresolvedNamespace, new java.util.ArrayList[TypeProjection]())
 
   val primitiveArrayMappings: Map[String, String] = Map[String, String](
     "kotlin.BooleanArray" -> "boolean[]",
@@ -44,9 +32,8 @@ object TypeRenderer {
     opts.setParameterNamesInFunctionalTypes(false)
     opts.setInformativeErrorType(false)
     opts.setTypeNormalizer {
-      case _: UnresolvedType => cpgUnresolvedType
-      case _: ErrorType      => cpgUnresolvedType
-      case t                 => t
+      case _: ErrorType => cpgUnresolvedType
+      case t            => t
     }
     new DescriptorRendererImpl(opts)
   }

joern-cli/frontends/kotlin2cpg/src/test/scala/io/joern/kotlin2cpg/querying/TypeAliasTests.scala

@@ -46,7 +46,7 @@ class TypeAliasTests extends KotlinCode2CpgFixture(withOssDataflow = false, with
       x.fullName shouldBe "mypkg.Id"
       x.isExternal shouldBe false
       x.inheritsFromTypeFullName shouldBe List()
-      x.aliasTypeFullName shouldBe Some(Defines.UnresolvedNamespace)
+      x.aliasTypeFullName shouldBe Some("ANY")
     }
   }