FIR: support type alias resolve

compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirTypeResolveTransformer.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
 import org.jetbrains.kotlin.fir.scopes.FirScope
@@ -59,6 +60,11 @@ class FirTypeResolveTransformer : FirTransformer<Nothing?>() {
         return result
     }
 
+    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        typeAlias.transformChildren(SuperTypeResolver(), null)
+        return super.transformTypeAlias(typeAlias, data)
+    }
+
     override fun transformType(type: FirType, data: Nothing?): CompositeTransformResult<FirType> {
         val typeResolver = FirTypeResolver.getInstance(type.session)
         return FirResolvedTypeImpl(

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirQualifierResolverImpl.kt

@@ -6,10 +6,13 @@
 package org.jetbrains.kotlin.fir.resolve.impl
 
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeKotlinTypeProjectionInImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeKotlinTypeProjectionOutImpl
@@ -19,23 +22,38 @@ import org.jetbrains.kotlin.types.Variance
 
 class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {
 
-    private fun FirMemberDeclaration.toConeKotlinType(fqName: ClassId, parts: List<FirQualifierPart>): ConeKotlinType? {
-        return ConeClassTypeImpl(fqName, parts.flatMap {
-            it.typeArguments.map {
-                when (it) {
-                    is FirStarProjection -> StarProjection
-                    is FirTypeProjectionWithVariance -> {
-                        val type = (it.type as FirResolvedType).type
-                        when (it.variance) {
-                            Variance.INVARIANT -> type
-                            Variance.IN_VARIANCE -> ConeKotlinTypeProjectionInImpl(type)
-                            Variance.OUT_VARIANCE -> ConeKotlinTypeProjectionOutImpl(type)
-                        }
+    private fun List<FirQualifierPart>.toTypeProjections() = flatMap {
+        it.typeArguments.map {
+            when (it) {
+                is FirStarProjection -> StarProjection
+                is FirTypeProjectionWithVariance -> {
+                    val type = (it.type as FirResolvedType).type
+                    when (it.variance) {
+                        Variance.INVARIANT -> type
+                        Variance.IN_VARIANCE -> ConeKotlinTypeProjectionInImpl(type)
+                        Variance.OUT_VARIANCE -> ConeKotlinTypeProjectionOutImpl(type)
                     }
-                    else -> error("!")
                 }
+                else -> error("!")
             }
-        })
+        }
+    }
+
+    private fun FirMemberDeclaration.toConeKotlinType(fqName: ClassId, parts: List<FirQualifierPart>): ConeKotlinType? {
+        return when (this) {
+            is FirClass -> {
+                ConeClassTypeImpl(fqName, parts.toTypeProjections())
+            }
+            is FirTypeAlias -> {
+                ConeAbbreviatedTypeImpl(
+                    abbreviationFqName = fqName,
+                    typeArguments = parts.toTypeProjections(),
+                    directExpansion = (this.abbreviatedType as FirResolvedType).type
+                )
+
+            }
+            else -> error("!")
+        }
     }
 
     override fun resolveTypeWithPrefix(parts: List<FirQualifierPart>, prefix: ClassId): ConeKotlinType? {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt

@@ -9,10 +9,13 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.types.ConeAbbreviatedType
 import org.jetbrains.kotlin.fir.types.ConeClassType
 import org.jetbrains.kotlin.fir.types.FirResolvedType
+import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -24,15 +27,26 @@ class FirNestedClassifierScope(val classId: ClassId, val session: FirSession) :
         return firProvider.getFirClassifierByFqName(this)
     }
 
+    private tailrec fun ConeClassType.computePartialExpansion(): ClassId {
+        return when (this) {
+            !is ConeAbbreviatedType -> this.fqName
+            else -> (this.directExpansion as ConeClassType).computePartialExpansion()
+        }
+    }
+
     private val superScopes by lazy {
         val self = classId.getFir()
         when (self) {
             is FirClass -> {
                 val superTypes = self.superTypes as List<FirResolvedType>
                 FirCompositeScope(superTypes.mapTo(ArrayList(superTypes.size)) {
-                    FirNestedClassifierScope((it.type as ConeClassType).fqName, session)
+                    FirNestedClassifierScope(it.coneTypeUnsafe<ConeClassType>().computePartialExpansion(), session)
                 })
             }
+            is FirTypeAlias -> {
+                val expansionTarget = self.abbreviatedType.coneTypeUnsafe<ConeClassType>().computePartialExpansion()
+                FirNestedClassifierScope(expansionTarget, session)
+            }
             else -> error("!")
         }
     }