FIR: Refactor Cone types

- Get rid of AbbreviatedType

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypes.kt

@@ -109,16 +109,10 @@ abstract class ConeLookupTagBasedType : ConeKotlinType(), SimpleTypeMarker {
     abstract val lookupTag: ConeClassifierLookupTag
 }
 
-sealed class ConeClassLikeType : ConeLookupTagBasedType() {
+abstract class ConeClassLikeType : ConeLookupTagBasedType() {
     abstract override val lookupTag: ConeClassLikeLookupTag
 }
 
-abstract class ConeClassType : ConeClassLikeType()
-
-abstract class ConeAbbreviatedType : ConeClassLikeType() {
-    abstract val abbreviationLookupTag: ConeClassLikeLookupTag
-}
-
 open class ConeFlexibleType(val lowerBound: ConeKotlinType, val upperBound: ConeKotlinType) : ConeKotlinType(),
     FlexibleTypeMarker {
 

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/impl/Impl.kt

@@ -6,13 +6,15 @@
 package org.jetbrains.kotlin.fir.types.impl
 
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.ConeKotlinTypeProjection
+import org.jetbrains.kotlin.fir.types.ConeNullability
 
 open class ConeClassLikeTypeImpl(
     override val lookupTag: ConeClassLikeLookupTag,
     override val typeArguments: Array<out ConeKotlinTypeProjection>,
     isNullable: Boolean
-) : ConeClassType() {
+) : ConeClassLikeType() {
     override val nullability: ConeNullability = ConeNullability.create(isNullable)
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
@@ -34,15 +36,3 @@ open class ConeClassLikeTypeImpl(
         return result
     }
 }
-
-class ConeAbbreviatedTypeImpl(
-    override val abbreviationLookupTag: ConeClassLikeLookupTag,
-    override val typeArguments: Array<out ConeKotlinTypeProjection>,
-    isNullable: Boolean
-) : ConeAbbreviatedType() {
-    override val lookupTag: ConeClassLikeLookupTag
-        get() = abbreviationLookupTag
-
-    override val nullability: ConeNullability = ConeNullability.create(isNullable)
-}
-

compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt

@@ -21,12 +21,17 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
 import org.jetbrains.kotlin.fir.expressions.impl.FirUnitExpression
 import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
-import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.directExpansionType
+import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.toSymbol
+import org.jetbrains.kotlin.fir.resolve.withNullability
+import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.resolve.diagnostics.FirAmbiguityError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.FirInapplicableCandidateError
-import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.FirTypePlaceholderProjection
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
@@ -635,8 +640,19 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
 
     private fun FlowContent.generate(type: ConeClassLikeType) {
         resolved {
-            symbolRef(type.lookupTag.toSymbol(session)) {
+            when (val symbol = type.lookupTag.toSymbol(session)) {
-                fqn(type.lookupTag.classId.relativeClassName)
+                is FirTypeAliasSymbol -> {
+                    symbolRef(symbol) {
+                        simpleName(type.lookupTag.name)
+                    }
+                    +" = "
+                    generate(type.directExpansionType(session) ?: ConeKotlinErrorType("No expansion for type-alias"))
+                }
+                else -> {
+                    symbolRef(symbol) {
+                        fqn(type.lookupTag.classId.relativeClassName)
+                    }
+                }
             }
         }
     }
@@ -720,13 +736,6 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         when (type) {
             is ConeClassErrorType -> error { +type.reason }
             is ConeClassLikeType -> generate(type)
-            is ConeAbbreviatedType -> resolved {
-                symbolRef(type.abbreviationLookupTag.toSymbol(session)) {
-                    simpleName(type.abbreviationLookupTag.name)
-                }
-                +" = "
-                generate(type.directExpansionType(session) ?: ConeKotlinErrorType("No expansion for type-alias"))
-            }
             is ConeTypeParameterType -> resolved {
                 symbolRef(type.lookupTag.toSymbol()) {
                     simpleName(type.lookupTag.name)

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.fir.resolve.directExpansionType
 import org.jetbrains.kotlin.fir.resolve.firProvider
+import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.resolveSupertypesInTheAir
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
@@ -208,10 +208,8 @@ private fun createJavaFileStub(packageFqName: FqName, files: Collection<KtFile>)
 }
 
 private fun ConeClassLikeType.toFirClass(session: FirSession): FirRegularClass? {
-    return when (this) {
+    val expandedType = this.fullyExpandedType(session)
-        is ConeAbbreviatedType -> this.directExpansionType(session)?.toFirClass(session)
+    return (expandedType.lookupTag.toSymbol(session) as? FirClassSymbol)?.fir as? FirRegularClass
-        else -> (this.lookupTag.toSymbol(session) as? FirClassSymbol)?.fir
-    } as? FirRegularClass
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -232,13 +230,12 @@ private fun ConeKotlinType.mapToCanonicalString(session: FirSession): String {
 
 private fun ConeClassLikeType.mapToCanonicalString(session: FirSession): String {
     return when (this) {
-        is ConeAbbreviatedType -> this.directExpansionType(session)?.mapToCanonicalString(session) ?: ERROR_TYPE_STUB
-        is ConeClassType -> mapToCanonicalString(session)
         is ConeClassErrorType -> ERROR_TYPE_STUB
+        else -> fullyExpandedType(session).mapToCanonicalNoExpansionString(session)
     }
 }
 
-private fun ConeClassType.mapToCanonicalString(session: FirSession): String {
+private fun ConeClassLikeType.mapToCanonicalNoExpansionString(session: FirSession): String {
     if (lookupTag.classId == StandardClassIds.Array) {
         return when (val typeProjection = typeArguments[0]) {
             is ConeStarProjection -> CommonClassNames.JAVA_LANG_OBJECT

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt

@@ -10,12 +10,13 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
 import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary
 import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.resolve.toTypeProjection
-import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
+import org.jetbrains.kotlin.fir.symbols.ConeClassifierLookupTag
+import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
@@ -133,7 +134,7 @@ class FirTypeDeserializer(
 
         val abbreviatedTypeProto = proto.abbreviatedType(typeTable) ?: return simpleType
 
-        return ConeAbbreviatedTypeImpl(typeSymbol(abbreviatedTypeProto) as ConeClassLikeLookupTag, arguments, isNullable = false)
+        return ConeClassLikeTypeImpl(typeSymbol(abbreviatedTypeProto) as ConeClassLikeLookupTag, arguments, isNullable = false)
 
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -10,8 +10,8 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.componentArrayAccessor
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirStubDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.FirStubDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirResolvable
@@ -31,7 +31,10 @@ import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.*
+import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
+import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
+import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
+import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
@@ -60,11 +63,19 @@ fun ConeClassLikeLookupTag.toSymbol(useSiteSession: FirSession): FirClassLikeSym
     return firSymbolProvider.getSymbolByLookupTag(this)
 }
 
-fun ConeAbbreviatedType.directExpansionType(
+tailrec fun ConeClassLikeType.fullyExpandedType(
+    useSiteSession: FirSession,
+    expandedConeType: (FirTypeAlias) -> ConeClassLikeType? = FirTypeAlias::expandedConeType
+): ConeClassLikeType {
+    val directExpansionType = directExpansionType(useSiteSession, expandedConeType) ?: return this
+    return directExpansionType.fullyExpandedType(useSiteSession, expandedConeType)
+}
+
+fun ConeClassLikeType.directExpansionType(
     useSiteSession: FirSession,
     expandedConeType: (FirTypeAlias) -> ConeClassLikeType? = FirTypeAlias::expandedConeType
 ): ConeClassLikeType? {
-    val typeAlias = abbreviationLookupTag
+    val typeAlias = lookupTag
         .toSymbol(useSiteSession)
         ?.safeAs<FirTypeAliasSymbol>()?.fir ?: return null
 
@@ -73,7 +84,11 @@ fun ConeAbbreviatedType.directExpansionType(
     return mapTypeAliasArguments(typeAlias, this, resultType) as? ConeClassLikeType
 }
 
-private fun mapTypeAliasArguments(typeAlias: FirTypeAlias, abbreviatedType: ConeAbbreviatedType, resultingType: ConeClassLikeType): ConeKotlinType {
+private fun mapTypeAliasArguments(
+    typeAlias: FirTypeAlias,
+    abbreviatedType: ConeClassLikeType,
+    resultingType: ConeClassLikeType
+): ConeKotlinType {
     val typeAliasMap = typeAlias.typeParameters.map { it.symbol }.zip(abbreviatedType.typeArguments).toMap()
 
     val substitutor = object : AbstractConeSubstitutor() {
@@ -129,8 +144,8 @@ fun FirClassifierSymbol<*>.constructType(typeArguments: Array<ConeKotlinTypeProj
             ConeClassLikeTypeImpl(this.toLookupTag(), typeArguments, isNullable)
         }
         is FirTypeAliasSymbol -> {
-            ConeAbbreviatedTypeImpl(
+            ConeClassLikeTypeImpl(
-                abbreviationLookupTag = this.toLookupTag(),
+                this.toLookupTag(),
                 typeArguments = typeArguments,
                 isNullable = isNullable
             )
@@ -170,12 +185,7 @@ fun <T : ConeKotlinType> T.withNullability(nullability: ConeNullability): T {
 
     return when (this) {
         is ConeClassErrorType -> this
-        is ConeClassTypeImpl -> ConeClassTypeImpl(lookupTag, typeArguments, nullability.isNullable) as T
+        is ConeClassLikeTypeImpl -> ConeClassLikeTypeImpl(lookupTag, typeArguments, nullability.isNullable) as T
-        is ConeAbbreviatedTypeImpl -> ConeAbbreviatedTypeImpl(
-            abbreviationLookupTag,
-            typeArguments,
-            nullability.isNullable
-        ) as T
         is ConeTypeParameterTypeImpl -> ConeTypeParameterTypeImpl(lookupTag, nullability.isNullable) as T
         is ConeFlexibleType -> ConeFlexibleType(lowerBound.withNullability(nullability), upperBound.withNullability(nullability)) as T
         is ConeTypeVariableType -> ConeTypeVariableType(nullability, lookupTag) as T
@@ -205,12 +215,7 @@ fun <T : ConeKotlinType> T.withArguments(arguments: Array<out ConeKotlinTypeProj
 
     return when (this) {
         is ConeClassErrorType -> this
-        is ConeClassTypeImpl -> ConeClassTypeImpl(lookupTag, arguments, nullability.isNullable) as T
+        is ConeClassLikeTypeImpl -> ConeClassLikeTypeImpl(lookupTag, arguments, nullability.isNullable) as T
-        is ConeAbbreviatedTypeImpl -> ConeAbbreviatedTypeImpl(
-            abbreviationLookupTag,
-            arguments,
-            nullability.isNullable
-        ) as T
         is ConeDefinitelyNotNullType -> ConeDefinitelyNotNullType.create(original.withArguments(arguments)) as T
         else -> error("Not supported: $this: ${this.render()}")
     }
@@ -366,4 +371,4 @@ fun BodyResolveComponents.transformQualifiedAccessUsingSmartcastInfo(qualifiedAc
         annotations += qualifiedAccessExpression.resultType.annotations
     }
     return FirExpressionWithSmartcastImpl(qualifiedAccessExpression, intersectedTypeRef, typesFromSmartCast)
-}
+}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt

@@ -56,7 +56,7 @@ class FirSamResolverImpl(
             )
             is ConeClassErrorType, is ConeStubType -> null
             // TODO: support those types as well
-            is ConeAbbreviatedType, is ConeTypeParameterType, is ConeTypeVariableType,
+            is ConeTypeParameterType, is ConeTypeVariableType,
             is ConeCapturedType, is ConeDefinitelyNotNullType, is ConeIntersectionType -> null
             // TODO: Thing of getting rid of this branch since ConeLookupTagBasedType should be a sealed class
             is ConeLookupTagBasedType -> null

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt

@@ -18,11 +18,15 @@ import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
     return when (this) {
         is ConeKotlinErrorType -> null
-        is ConeAbbreviatedType -> directExpansionType(useSiteSession)?.scope(useSiteSession, scopeSession)
         is ConeClassLikeType -> {
-            // TODO: for ConeClassLikeType they might be a type alias instead of a class
+            val fullyExpandedType = fullyExpandedType(useSiteSession)
-            val fir = this.lookupTag.toSymbol(useSiteSession)?.fir as? FirClass<*> ?: return null
+            val fir = fullyExpandedType.lookupTag.toSymbol(useSiteSession)?.fir as? FirClass<*> ?: return null
-            wrapSubstitutionScopeIfNeed(useSiteSession, fir.buildUseSiteMemberScope(useSiteSession, scopeSession)!!, fir, scopeSession)
+            fullyExpandedType.wrapSubstitutionScopeIfNeed(
+                useSiteSession,
+                fir.buildUseSiteMemberScope(useSiteSession, scopeSession)!!,
+                fir,
+                scopeSession
+            )
         }
         is ConeTypeParameterType -> {
             // TODO: support LibraryTypeParameterSymbol or get rid of it

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt

@@ -132,18 +132,10 @@ fun ConeClassLikeType.wrapSubstitutionScopeIfNeed(
     }
 }
 
-private tailrec fun ConeClassLikeType.computePartialExpansion(
+private fun ConeClassLikeType.computePartialExpansion(
     useSiteSession: FirSession,
     supertypeSupplier: SupertypeSupplier
-): ConeClassLikeType? {
+): ConeClassLikeType = fullyExpandedType(useSiteSession, supertypeSupplier::expansionForTypeAlias)
-    return when (this) {
-        is ConeAbbreviatedType ->
-            directExpansionType(useSiteSession) {
-                supertypeSupplier.expansionForTypeAlias(it)
-            }?.computePartialExpansion(useSiteSession, supertypeSupplier)
-        else -> this
-    }
-}
 
 private fun FirClassifierSymbol<*>.collectSuperTypes(
     list: MutableList<ConeClassLikeType>,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt

@@ -93,7 +93,7 @@ class ImplicitDispatchReceiverValue(
         val klass = boundSymbol.fir as? FirRegularClass ?: return@run emptyList()
         listOfNotNull(klass.companionObject?.buildUseSiteMemberScope(useSiteSession, scopeSession)) +
                 lookupSuperTypes(klass, lookupInterfaces = false, deep = true, useSiteSession = useSiteSession).mapNotNull {
-                    val superClass = (it as? ConeClassType)?.lookupTag?.toSymbol(useSiteSession)?.fir as? FirRegularClass
+                    val superClass = (it as? ConeClassLikeType)?.lookupTag?.toSymbol(useSiteSession)?.fir as? FirRegularClass
                     superClass?.companionObject?.buildUseSiteMemberScope(useSiteSession, scopeSession)
                 }
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/PostponedArguments.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.invoke
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
+import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilder
 import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystemConstraintPosition
 import org.jetbrains.kotlin.resolve.calls.model.PostponedResolvedAtomMarker
@@ -61,7 +61,7 @@ fun Candidate.preprocessCallableReference(
 val ConeKotlinType.isBuiltinFunctionalType: Boolean
     get() {
         return when (this) {
-            is ConeClassType -> this.lookupTag.classId.asString().startsWith("kotlin/Function")
+            is ConeClassLikeType -> this.lookupTag.classId.asString().startsWith("kotlin/Function")
             else -> false
         }
     }
@@ -71,7 +71,7 @@ private val ConeKotlinType.isSuspendFunctionType: Boolean
     get() {
         val type = this
         return when (type) {
-            is ConeClassType -> {
+            is ConeClassLikeType -> {
                 val classId = type.lookupTag.classId
                 classId.packageFqName.asString() == "kotlin" && classId.relativeClassName.asString().startsWith("SuspendFunction")
             }
@@ -88,14 +88,14 @@ private fun ConeKotlinType.receiverType(expectedTypeRef: FirTypeRef): ConeKotlin
 
 val ConeKotlinType.returnType: ConeKotlinType?
     get() {
-        require(this is ConeClassType)
+        require(this is ConeClassLikeType)
         val projection = typeArguments.last()
         return (projection as? ConeTypedProjection)?.type
     }
 
 val ConeKotlinType.valueParameterTypes: List<ConeKotlinType?>
     get() {
-        require(this is ConeClassType)
+        require(this is ConeClassLikeType)
         return typeArguments.dropLast(1).map {
             (it as? ConeTypedProjection)?.type
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractImportingScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitSimpleImportingScope
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.types.ConeAbbreviatedType
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
 import org.jetbrains.kotlin.name.FqName
@@ -324,14 +323,13 @@ private fun FirScope.getFirstClassifierOrNull(name: Name): FirClassifierSymbol<*
 }
 
 private fun finalExpansionName(symbol: FirTypeAliasSymbol, session: FirSession): Name? {
-    return when (val expandedType = symbol.fir.expandedTypeRef.coneTypeUnsafe<ConeClassLikeType>()) {
+    val expandedType = symbol.fir.expandedTypeRef.coneTypeUnsafe<ConeClassLikeType>()
-        is ConeAbbreviatedType ->
+    val typeAliasSymbol = expandedType.lookupTag.toSymbol(session)?.safeAs<FirTypeAliasSymbol>()
-            expandedType.abbreviationLookupTag.toSymbol(session)?.safeAs<FirTypeAliasSymbol>()?.let {
-                finalExpansionName(it, session)
-            }
-        else -> expandedType.lookupTag.classId.shortClassName
-    }
 
+    return if (typeAliasSymbol != null)
+        finalExpansionName(typeAliasSymbol, session)
+    else
+        expandedType.lookupTag.classId.shortClassName
 }
 
 val SAM_PARAMETER_NAME = Name.identifier("block")

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/substitution/ConeSubstitutor.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.resolve.substitution
 import org.jetbrains.kotlin.fir.resolve.withNullability
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.types.model.TypeSubstitutorMarker
 
@@ -68,8 +67,7 @@ abstract class AbstractConeSubstitutor : ConeSubstitutor() {
     private fun ConeKotlinType.substituteRecursive(): ConeKotlinType? {
         return when (this) {
             is ConeClassErrorType -> return null
-            is ConeClassType -> this.substituteArguments()
+            is ConeClassLikeType -> this.substituteArguments()
-            is ConeAbbreviatedType -> this.substituteArguments()
             is ConeLookupTagBasedType -> return null
             is ConeFlexibleType -> this.substituteBounds()
             is ConeCapturedType -> return null
@@ -130,11 +128,6 @@ abstract class AbstractConeSubstitutor : ConeSubstitutor() {
                     newArguments as Array<ConeKotlinTypeProjection>,
                     nullability.isNullable
                 )
-                is ConeAbbreviatedTypeImpl -> ConeAbbreviatedTypeImpl(
-                    abbreviationLookupTag,
-                    newArguments as Array<ConeKotlinTypeProjection>,
-                    nullability.isNullable
-                )
                 is ConeClassLikeType -> error("Unknown class-like type to substitute: $this, ${this::class}")
                 else -> error("Unknown type to substitute: $this, ${this::class}")
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt

@@ -248,8 +248,8 @@ private class FirSupertypeResolverVisitor(
                     )
 
             val type = resolvedTypeRef.type
-            if (type is ConeAbbreviatedType) {
+            if (type is ConeClassLikeType) {
-                val expansionTypeAlias = type.abbreviationLookupTag.toSymbol(session)?.safeAs<FirTypeAliasSymbol>()?.fir
+                val expansionTypeAlias = type.lookupTag.toSymbol(session)?.safeAs<FirTypeAliasSymbol>()?.fir
                 if (expansionTypeAlias != null) {
                     visitTypeAlias(expansionTypeAlias)
                 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ArrayUtils.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.symbols.invoke
 fun ConeKotlinType.createArrayOf(session: FirSession, nullable: Boolean = false): ConeKotlinType {
     val symbolProvider: FirSymbolProvider = session.firSymbolProvider
     val type = lowerBoundIfFlexible()
-    if (type is ConeClassType) {
+    if (type is ConeClassLikeType) {
         val primitiveArrayId = StandardClassIds.primitiveArrayTypeByElementType[type.lookupTag.classId]
         if (primitiveArrayId != null) {
             return primitiveArrayId.invoke(symbolProvider).constructType(emptyArray(), nullable)
@@ -29,7 +29,7 @@ fun ConeKotlinType.createArrayOf(session: FirSession, nullable: Boolean = false)
 
 fun ConeKotlinType.arrayElementType(session: FirSession): ConeKotlinType? {
     val type = this.lowerBoundIfFlexible()
-    if (type !is ConeClassType) return null
+    if (type !is ConeClassLikeType) return null
     val classId = type.lookupTag.classId
     if (classId == StandardClassIds.Array)
         return (type.typeArguments.first() as ConeTypedProjection).type
@@ -39,4 +39,4 @@ fun ConeKotlinType.arrayElementType(session: FirSession): ConeKotlinType? {
     }
 
     return null
-}
+}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt

@@ -58,8 +58,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
     override fun KotlinTypeMarker.asSimpleType(): SimpleTypeMarker? {
         assert(this is ConeKotlinType)
         return when (this) {
-            is ConeAbbreviatedType -> directExpansionType(session)
+            is ConeClassLikeType -> fullyExpandedType(session)
-                ?: ConeClassErrorType("no expansion for type-alias: ${this.abbreviationLookupTag.classId}")
             is ConeCapturedType -> this
             is ConeLookupTagBasedType -> this
             is ConeDefinitelyNotNullType -> this
@@ -126,24 +125,17 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
     }
 
     override fun SimpleTypeMarker.typeConstructor(): TypeConstructorMarker {
-        val typeConstructor = when (this) {
+        return when (this) {
             is ConeCapturedType -> constructor
-            is ConeTypeVariableType -> this.lookupTag as ConeTypeVariableTypeConstructor // TODO: WTF
+            is ConeTypeVariableType -> lookupTag as ConeTypeVariableTypeConstructor // TODO: WTF
-            is ConeAbbreviatedType -> this.directExpansionType(session)?.typeConstructor()
+            is ConeClassLikeType -> lookupTag.toSymbol(session)
-                ?: ErrorTypeConstructor("Failed to expand alias: $this")
+                ?: ErrorTypeConstructor("Unresolved: $lookupTag")
-            is ConeLookupTagBasedType -> this.lookupTag.toSymbol(session) ?: ErrorTypeConstructor("Unresolved: ${this.lookupTag}")
+            is ConeLookupTagBasedType -> lookupTag.toSymbol(session) ?: ErrorTypeConstructor("Unresolved: $lookupTag")
             is ConeIntersectionType -> this
             is ConeStubType -> variable.typeConstructor
             is ConeDefinitelyNotNullType -> original.typeConstructor()
             else -> error("?: $this")
         }
-
-        // TODO: get rid of class types with type-alias symbols
-        if (typeConstructor is FirTypeAliasSymbol) {
-            return typeConstructor.fir.expandedTypeRef.coneTypeSafe<ConeKotlinType>()?.typeConstructor()
-                ?: ErrorTypeConstructor("Failed to expand alias: ${this}")
-        }
-        return typeConstructor
     }
 
     override fun CapturedTypeMarker.typeConstructor(): CapturedTypeConstructorMarker {
@@ -401,28 +393,9 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
         return ConeTypeIntersector.intersectTypes(this as ConeInferenceContext, types as List<ConeKotlinType>)
     }
 
-    private fun prepareClassLikeType(
-        type: ConeClassLikeType,
-        visited: MutableSet<ConeAbbreviatedType>
-    ): KotlinTypeMarker {
-        return when (type) {
-            is ConeAbbreviatedType -> prepareAbbreviatedType(type, visited)
-            else -> type
-        }
-    }
-
-    private fun prepareAbbreviatedType(
-        type: ConeAbbreviatedType,
-        visited: MutableSet<ConeAbbreviatedType> = mutableSetOf()
-    ): KotlinTypeMarker {
-        if (type in visited) return ConeClassErrorType("Recursive type alias")
-        visited += type
-        return prepareClassLikeType(type.directExpansionType(session) ?: ConeClassErrorType("unresolved"), visited)
-    }
-
     override fun prepareType(type: KotlinTypeMarker): KotlinTypeMarker {
         return when (type) {
-            is ConeAbbreviatedType -> prepareAbbreviatedType(type)
+            is ConeClassLikeType -> type.fullyExpandedType(session)
             else -> type
         }
     }
@@ -528,11 +501,11 @@ class ConeTypeCheckerContext(
         if (type.argumentsCount() == 0) return SupertypesPolicy.LowerIfFlexible
         require(type is ConeKotlinType)
         val declaration = when (type) {
-            is ConeClassType -> type.lookupTag.toSymbol(session)?.firUnsafe<FirRegularClass>()
+            is ConeClassLikeType -> type.lookupTag.toSymbol(session)?.firUnsafe<FirClassLikeDeclaration<*>>()
             else -> null
         }
 
-        val substitutor = if (declaration != null) {
+        val substitutor = if (declaration is FirTypeParametersOwner) {
             val substitution =
                 declaration.typeParameters.zip(type.typeArguments).associate { (parameter, argument) ->
                     parameter.symbol to ((argument as? ConeTypedProjection)?.type
@@ -560,6 +533,10 @@ class ConeTypeCheckerContext(
         return super<ConeTypeContext>.prepareType(type)
     }
 
+    override fun refineType(type: KotlinTypeMarker): KotlinTypeMarker {
+        return prepareType(type)
+    }
+
     override val KotlinTypeMarker.isAllowedTypeVariable: Boolean
         get() = this is ConeKotlinType && this is ConeTypeVariableType
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt

@@ -7,20 +7,18 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirErrorLoopImpl
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
 import org.jetbrains.kotlin.name.ClassId
 
 inline val FirAnnotationCall.coneClassLikeType: ConeClassLikeType?
-    get() = ((annotationTypeRef as? FirResolvedTypeRef)?.type as? ConeClassLikeType)?.takeIf { it !is ConeClassErrorType }
+    get() = ((annotationTypeRef as? FirResolvedTypeRef)?.type as? ConeClassLikeType)
 
 inline val FirAnnotationCall.classId: ClassId?
     get() = coneClassLikeType?.lookupTag?.classId

compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitBuiltinTypeRef.kt

@@ -26,7 +26,7 @@ sealed class FirImplicitBuiltinTypeRef(
     override val annotations: List<FirAnnotationCall>
         get() = emptyList()
 
-    override val type: ConeClassLikeType = ConeClassTypeImpl(ConeClassLikeLookupTagImpl(id), typeArguments, isNullable)
+    override val type: ConeClassLikeType = ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(id), typeArguments, isNullable)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
 
@@ -74,4 +74,4 @@ class FirImplicitStringTypeRef(
 class FirImplicitKPropertyTypeRef(
     source: FirSourceElement?,
     typeArgument: ConeKotlinTypeProjection
-) : FirImplicitBuiltinTypeRef(source, StandardClassIds.KProperty, arrayOf(typeArgument))
+) : FirImplicitBuiltinTypeRef(source, StandardClassIds.KProperty, arrayOf(typeArgument))

compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt

@@ -467,7 +467,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() {
         override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: StringBuilder) {
             val coneType = resolvedTypeRef.type
             data.append(removeCurrentFilePackage(coneType.render()))
-            if (coneType is ConeAbbreviatedType) {
+            if (coneType is ConeClassLikeType) {
                 val original = coneType.directExpansionType(session)
                 original?.let { data.append(" /* = ${it.render()} */") }
             }