[FIR] Introduce utility for creating ConeClassLikeLookupTagImpl from ClassId

`classId.toLookupTag()` looks much cleaner than `ConeClassLikeLookupTagImpl(classId)`

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt

@@ -37,7 +37,6 @@ import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator
 import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitSimpleImportingScope
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.lexer.KtTokens
@@ -72,7 +71,7 @@ internal object FirReferenceResolveHelper {
         symbolBuilder: KtSymbolByFirBuilder,
         calleeReference: FirReference? = null,
     ): KtSymbol? {
-        val classLikeDeclaration = ConeClassLikeLookupTagImpl(this).toSymbol(session)?.fir
+        val classLikeDeclaration = this.toLookupTag().toSymbol(session)?.fir
         if (classLikeDeclaration is FirRegularClass) {
             if (calleeReference is FirResolvedNamedReference) {
                 val callee = calleeReference.resolvedSymbol.fir as? FirCallableDeclaration

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOperatorModifierChecker.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.declarations.utils.isOperator
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.lexer.KtTokens
@@ -164,7 +163,7 @@ private object Checks {
         paramType.isSupertypeOf(
             ctx.session.typeContext,
             ConeClassLikeTypeImpl(
-                ConeClassLikeLookupTagImpl(StandardClassIds.KProperty),
+                StandardClassIds.KProperty.toLookupTag(),
                 arrayOf(ConeStarProjection),
                 isNullable = false
             )

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.fir.resolve.scope
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator
 import org.jetbrains.kotlin.fir.scopes.getDeclaredConstructors
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.lazyDeclarationResolver
 import org.jetbrains.kotlin.fir.types.*
@@ -181,7 +180,7 @@ abstract class AbstractAnnotationDeserializer(
         val classId = nameResolver.getClassId(proto.id)
         return buildAnnotation {
             annotationTypeRef = buildResolvedTypeRef {
-                type = ConeClassLikeLookupTagImpl(classId).constructClassType(emptyArray(), isNullable = false)
+                type = classId.toLookupTag().constructClassType(emptyArray(), isNullable = false)
             }
             session.lazyDeclarationResolver.disableLazyResolveContractChecksInside {
                 this.argumentMapping = createArgumentMapping(proto, classId, nameResolver)
@@ -202,7 +201,7 @@ abstract class AbstractAnnotationDeserializer(
             // Used only for annotation parameters of array types
             // Avoid triggering it in other cases, since it's quite expensive
             val parameterByName: Map<Name, FirValueParameter>? by lazy(LazyThreadSafetyMode.NONE) {
-                val lookupTag = ConeClassLikeLookupTagImpl(classId)
+                val lookupTag = classId.toLookupTag()
                 val symbol = lookupTag.toSymbol(session)
                 val firAnnotationClass = (symbol as? FirRegularClassSymbol)?.fir ?: return@lazy null
 
@@ -259,7 +258,7 @@ abstract class AbstractAnnotationDeserializer(
             ANNOTATION -> deserializeAnnotation(value.annotation, nameResolver)
             CLASS -> buildGetClassCall {
                 val classId = nameResolver.getClassId(value.classId)
-                val lookupTag = ConeClassLikeLookupTagImpl(classId)
+                val lookupTag = classId.toLookupTag()
                 val referencedType = lookupTag.constructType(emptyArray(), isNullable = false)
                 val resolvedTypeRef = buildResolvedTypeRef {
                     type = StandardClassIds.KClass.constructClassLikeType(arrayOf(referencedType), false)
@@ -276,7 +275,7 @@ abstract class AbstractAnnotationDeserializer(
                 val classId = nameResolver.getClassId(value.classId)
                 val entryName = nameResolver.getName(value.enumValueId)
 
-                val enumLookupTag = ConeClassLikeLookupTagImpl(classId)
+                val enumLookupTag = classId.toLookupTag()
                 val enumSymbol = enumLookupTag.toSymbol(session)
                 val firClass = enumSymbol?.fir as? FirRegularClass
                 val enumEntries = firClass?.collectEnumEntries() ?: emptyList()

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt

@@ -6,23 +6,30 @@
 package org.jetbrains.kotlin.fir.deserialization
 
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures
-import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.*
 import org.jetbrains.kotlin.fir.declarations.comparators.FirMemberDeclarationComparator
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
-import org.jetbrains.kotlin.fir.declarations.utils.*
+import org.jetbrains.kotlin.fir.declarations.utils.addDeclarations
+import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
+import org.jetbrains.kotlin.fir.declarations.utils.moduleName
+import org.jetbrains.kotlin.fir.declarations.utils.sourceElement
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
+import org.jetbrains.kotlin.fir.types.toLookupTag
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinarySourceElement
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.*
@@ -259,7 +266,7 @@ private fun FirRegularClassBuilder.addSerializableIfNeeded(classId: ClassId) {
     if (!JvmBuiltInsSignatures.isSerializableInJava(classId.asSingleFqName().toUnsafe())) return
     superTypeRefs += buildResolvedTypeRef {
         type = ConeClassLikeTypeImpl(
-            ConeClassLikeLookupTagImpl(JAVA_IO_SERIALIZABLE),
+            JAVA_IO_SERIALIZABLE.toLookupTag(),
             typeArguments = emptyArray(),
             isNullable = false
         )
@@ -271,7 +278,7 @@ private fun FirRegularClassBuilder.addCloneForArrayIfNeeded(classId: ClassId, di
     if (classId.shortClassName !in ARRAY_CLASSES) return
     superTypeRefs += buildResolvedTypeRef {
         type = ConeClassLikeTypeImpl(
-            ConeClassLikeLookupTagImpl(StandardClassIds.Cloneable),
+            StandardClassIds.Cloneable.toLookupTag(),
             typeArguments = emptyArray(),
             isNullable = false
         )
@@ -291,7 +298,7 @@ private fun FirRegularClassBuilder.addCloneForArrayIfNeeded(classId: ClassId, di
                 emptyArray()
             }
             type = ConeClassLikeTypeImpl(
-                ConeClassLikeLookupTagImpl(classId),
+                classId.toLookupTag(),
                 typeArguments = typeArguments,
                 isNullable = false
             )

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

@@ -20,7 +20,6 @@ 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.FirBasedSymbol
-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.*
@@ -101,7 +100,7 @@ class FirTypeDeserializer(
             // We can't just load local types as is, because later we will get an exception
             // while trying to get corresponding FIR class
             val id = nameResolver.getClassId(fqNameIndex).takeIf { !it.isLocal } ?: StandardClassIds.Any
-            return ConeClassLikeLookupTagImpl(id)
+            return id.toLookupTag()
         } catch (e: Throwable) {
             if (shouldIjPlatformExceptionBeRethrown(e)) throw e
             throw RuntimeException("Looking up for ${nameResolver.getClassId(fqNameIndex)}", e)
@@ -205,7 +204,7 @@ class FirTypeDeserializer(
 
         val kind = FunctionClassKind.SuspendFunction
         return ConeClassLikeTypeImpl(
-            ConeClassLikeLookupTagImpl(ClassId(kind.packageFqName, kind.numberedClassName(valueParameters.size))),
+            ClassId(kind.packageFqName, kind.numberedClassName(valueParameters.size)).toLookupTag(),
             (valueParameters + suspendReturnType).toTypedArray(),
             isNullable, attributes
         )
@@ -225,7 +224,7 @@ class FirTypeDeserializer(
                     if (arity >= 0) {
                         val kind = FunctionClassKind.SuspendFunction
                         ConeClassLikeTypeImpl(
-                            ConeClassLikeLookupTagImpl(ClassId(kind.packageFqName, kind.numberedClassName(arity))),
+                            ClassId(kind.packageFqName, kind.numberedClassName(arity)).toLookupTag(),
                             arguments,
                             isNullable,
                             attributes

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt

@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.constructClassType
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
+import org.jetbrains.kotlin.fir.types.toLookupTag
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
 import org.jetbrains.kotlin.metadata.deserialization.NameResolverImpl
@@ -291,7 +292,7 @@ private class SyntheticFunctionalInterfaceCache(private val moduleData: FirModul
                         kind: FunctionClassKind,
                     ): FirResolvedTypeRef {
                         return buildResolvedTypeRef {
-                            type = ConeClassLikeLookupTagImpl(kind.classId(arity))
+                            type = kind.classId(arity).toLookupTag()
                                 .constructClassType(typeArguments.map { it.type }.toTypedArray(), isNullable = false)
                         }
                     }
@@ -299,21 +300,21 @@ private class SyntheticFunctionalInterfaceCache(private val moduleData: FirModul
                     superTypeRefs += when (kind) {
                         FunctionClassKind.Function -> listOf(
                             buildResolvedTypeRef {
-                                type = ConeClassLikeLookupTagImpl(StandardClassIds.Function)
+                                type = StandardClassIds.Function.toLookupTag()
                                     .constructClassType(arrayOf(typeArguments.last().type), isNullable = false)
                             }
                         )
 
                         FunctionClassKind.SuspendFunction -> listOf(
                             buildResolvedTypeRef {
-                                type = ConeClassLikeLookupTagImpl(StandardClassIds.Function)
+                                type = StandardClassIds.Function.toLookupTag()
                                     .constructClassType(arrayOf(typeArguments.last().type), isNullable = false)
                             }
                         )
 
                         FunctionClassKind.KFunction -> listOf(
                             buildResolvedTypeRef {
-                                type = ConeClassLikeLookupTagImpl(StandardClassIds.KFunction)
+                                type = StandardClassIds.KFunction.toLookupTag()
                                     .constructClassType(arrayOf(typeArguments.last().type), isNullable = false)
                             },
                             createSuperType(FunctionClassKind.Function)
@@ -321,7 +322,7 @@ private class SyntheticFunctionalInterfaceCache(private val moduleData: FirModul
 
                         FunctionClassKind.KSuspendFunction -> listOf(
                             buildResolvedTypeRef {
-                                type = ConeClassLikeLookupTagImpl(StandardClassIds.KFunction)
+                                type = StandardClassIds.KFunction.toLookupTag()
                                     .constructClassType(arrayOf(typeArguments.last().type), isNullable = false)
                             },
                             createSuperType(FunctionClassKind.SuspendFunction)

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -36,7 +36,10 @@ import org.jetbrains.kotlin.fir.serialization.constant.EnumValue
 import org.jetbrains.kotlin.fir.serialization.constant.IntValue
 import org.jetbrains.kotlin.fir.serialization.constant.StringValue
 import org.jetbrains.kotlin.fir.serialization.constant.toConstantValue
-import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -775,7 +778,7 @@ class FirElementSerializer private constructor(
         val annotation = buildAnnotation {
             annotationTypeRef = buildResolvedTypeRef {
                 this.type = ConeClassLikeTypeImpl(
-                    ConeClassLikeLookupTagImpl(CompilerConeAttributes.classIdByCompilerAttributeKey.getValue(attribute.key)),
+                    CompilerConeAttributes.classIdByCompilerAttributeKey.getValue(attribute.key).toLookupTag(),
                     emptyArray(),
                     isNullable = false
                 )

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmTypeMapper.kt

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.fir.resolve.toSymbol
 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.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -49,8 +48,7 @@ import org.jetbrains.org.objectweb.asm.Type
 class FirJvmTypeMapper(val session: FirSession) : FirSessionComponent {
     companion object {
         val NON_EXISTENT_ID = ClassId.topLevel(StandardNames.NON_EXISTENT_CLASS)
-        private val typeForNonExistentClass = ConeClassLikeLookupTagImpl(NON_EXISTENT_ID)
-            .constructClassType(emptyArray(), isNullable = false)
+        private val typeForNonExistentClass = NON_EXISTENT_ID.toLookupTag().constructClassType(emptyArray(), isNullable = false)
     }
 
     fun mapType(

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt

@@ -20,10 +20,10 @@ import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.Fir2IrClassSymbol
 import org.jetbrains.kotlin.fir.symbols.Fir2IrEnumEntrySymbol
 import org.jetbrains.kotlin.fir.symbols.Fir2IrTypeAliasSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.toLookupTag
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
@@ -70,14 +70,14 @@ class Fir2IrClassifierStorage(
 
     fun preCacheBuiltinClasses() {
         for ((classId, irBuiltinSymbol) in typeConverter.classIdToSymbolMap) {
-            val firClass = ConeClassLikeLookupTagImpl(classId).toSymbol(session)!!.fir as FirRegularClass
+            val firClass = classId.toLookupTag().toSymbol(session)!!.fir as FirRegularClass
             val irClass = irBuiltinSymbol.owner
             classCache[firClass] = irClass
             processClassHeader(firClass, irClass)
             declarationStorage.preCacheBuiltinClassMembers(firClass, irClass)
         }
         for ((primitiveClassId, primitiveArrayId) in StandardClassIds.primitiveArrayTypeByElementType) {
-            val firClass = ConeClassLikeLookupTagImpl(primitiveArrayId).toSymbol(session)!!.fir as FirRegularClass
+            val firClass = primitiveArrayId.toLookupTag().toSymbol(session)!!.fir as FirRegularClass
             val irType = typeConverter.classIdToTypeMap[primitiveClassId]
             val irClass = irBuiltIns.primitiveArrayForType[irType]!!.owner
             classCache[firClass] = irClass
@@ -588,7 +588,7 @@ class Fir2IrClassifierStorage(
         )
 
         val parentId = classId.outerClassId
-        val parentClass = parentId?.let { getIrClassSymbolForNotFoundClass(ConeClassLikeLookupTagImpl(it)) }
+        val parentClass = parentId?.let { getIrClassSymbolForNotFoundClass(it.toLookupTag()) }
         val irParent = parentClass?.owner ?: declarationStorage.getIrExternalPackageFragment(classId.packageFqName)
 
         val symbol = Fir2IrClassSymbol(signature)

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt

@@ -826,7 +826,7 @@ class Fir2IrDeclarationStorage(
             createIrProperty(
                 field.toStubProperty(),
                 irParent,
-                fakeOverrideOwnerLookupTag = containingClassId?.let { ConeClassLikeLookupTagImpl(it) }
+                fakeOverrideOwnerLookupTag = containingClassId?.let { it.toLookupTag() }
             )
         }
     }
@@ -854,7 +854,7 @@ class Fir2IrDeclarationStorage(
         thisReceiverOwner: IrClass? = irParent as? IrClass,
         predefinedOrigin: IrDeclarationOrigin? = null,
         isLocal: Boolean = false,
-        fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag? = (irParent as? IrClass)?.classId?.let { ConeClassLikeLookupTagImpl(it) },
+        fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag? = (irParent as? IrClass)?.classId?.let { it.toLookupTag() },
         forceTopLevelPrivate: Boolean = false,
     ): IrProperty = convertCatching(property) {
         val origin =
@@ -1077,7 +1077,7 @@ class Fir2IrDeclarationStorage(
     ): IrField = convertCatching(field) {
         val type = typeRef.toIrType()
         val classId = (irParent as? IrClass)?.classId
-        val containingClassLookupTag = classId?.let { ConeClassLikeLookupTagImpl(it) }
+        val containingClassLookupTag = classId?.let { it.toLookupTag() }
         val signature = signatureComposer.composeSignature(field, containingClassLookupTag)
         return field.convertWithOffsets { startOffset, endOffset ->
             if (signature != null) {

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

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.effectiveVisibility
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.java.declarations.*
 import org.jetbrains.kotlin.fir.java.enhancement.FirSignatureEnhancement
-import org.jetbrains.kotlin.fir.types.constructType
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -463,7 +462,7 @@ abstract class FirJavaFacade(
                 resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
                 origin = javaOrigin(javaField.isFromSource)
             }.apply {
-                containingClassForStaticMemberAttr = ConeClassLikeLookupTagImpl(classId)
+                containingClassForStaticMemberAttr = classId.toLookupTag()
                 // TODO: check if this works properly with annotations that take the enum class as an argument
                 setAnnotationsFromJava(session, javaField, javaTypeParameterStack)
             }
@@ -500,7 +499,7 @@ abstract class FirJavaFacade(
                 }
             }.apply {
                 if (javaField.isStatic) {
-                    containingClassForStaticMemberAttr = ConeClassLikeLookupTagImpl(classId)
+                    containingClassForStaticMemberAttr = classId.toLookupTag()
                 }
             }
         }
@@ -555,7 +554,7 @@ abstract class FirJavaFacade(
             }
         }.apply {
             if (javaMethod.isStatic) {
-                containingClassForStaticMemberAttr = ConeClassLikeLookupTagImpl(classId)
+                containingClassForStaticMemberAttr = classId.toLookupTag()
             }
             if (containingClass.isRecord && valueParameters.isEmpty() && containingClass.recordComponents.any { it.name == methodName }) {
                 isJavaRecordComponent = true

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

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.java.enhancement.readOnlyToMutable
 import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
@@ -24,9 +23,6 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.types.Variance
 
-private fun ClassId.toLookupTag(): ConeClassLikeLookupTag =
-    ConeClassLikeLookupTagImpl(this)
-
 private fun ClassId.toConeFlexibleType(
     typeArguments: Array<out ConeTypeProjection>,
     typeArgumentsForUpper: Array<out ConeTypeProjection>,
@@ -186,7 +182,7 @@ private fun JavaClassifierType.toConeKotlinTypeForFlexibleBound(
                 classId = classId.readOnlyToMutable() ?: classId
             }
 
-            val lookupTag = ConeClassLikeLookupTagImpl(classId)
+            val lookupTag = classId.toLookupTag()
             // When converting type parameter bounds we should not attempt to load any classes, as this may trigger
             // enhancement of type parameter bounds on some other class that depends on this one. Also, in case of raw
             // types specifically there could be an infinite recursion on the type parameter itself.

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/AnnotationsLoader.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.providers.getClassDeclaredPropertySymbols
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -36,7 +35,7 @@ internal class AnnotationsLoader(private val session: FirSession, private val ko
     private fun loadAnnotation(
         annotationClassId: ClassId, result: MutableList<FirAnnotation>,
     ): KotlinJvmBinaryClass.AnnotationArgumentVisitor {
-        val lookupTag = ConeClassLikeLookupTagImpl(annotationClassId)
+        val lookupTag = annotationClassId.toLookupTag()
 
         return object : KotlinJvmBinaryClass.AnnotationArgumentVisitor {
             private val argumentMap = mutableMapOf<Name, FirExpression>()
@@ -48,7 +47,7 @@ internal class AnnotationsLoader(private val session: FirSession, private val ko
             }
 
             private fun ClassLiteralValue.toFirClassReferenceExpression(): FirClassReferenceExpression {
-                val resolvedClassTypeRef = ConeClassLikeLookupTagImpl(classId).toDefaultResolvedTypeRef()
+                val resolvedClassTypeRef = classId.toLookupTag().toDefaultResolvedTypeRef()
                 return buildClassReferenceExpression {
                     classTypeRef = resolvedClassTypeRef
                     typeRef = buildResolvedTypeRef {
@@ -83,7 +82,7 @@ internal class AnnotationsLoader(private val session: FirSession, private val ko
 
                     typeRef = buildResolvedTypeRef {
                         type = ConeClassLikeTypeImpl(
-                            ConeClassLikeLookupTagImpl(this@toEnumEntryReferenceExpression),
+                            this@toEnumEntryReferenceExpression.toLookupTag(),
                             emptyArray(),
                             isNullable = false
                         )

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt

@@ -489,7 +489,7 @@ class FirSignatureEnhancement(
             else -> return null
         }
         return ConeClassLikeTypeImpl(
-            ConeClassLikeLookupTagImpl(purelyImplementedClassId),
+            purelyImplementedClassId.toLookupTag(),
             parametersAsTypeProjections.toTypedArray(),
             isNullable = false
         )

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.ConeClassifierLookupTag
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.load.java.typeEnhancement.*
 import org.jetbrains.kotlin.name.ClassId
@@ -136,13 +135,13 @@ private fun ConeClassifierLookupTag.enhanceMutability(
         MutabilityQualifier.READ_ONLY -> {
             val readOnlyId = classId.mutableToReadOnly()
             if (position == TypeComponentPosition.FLEXIBLE_LOWER && readOnlyId != null) {
-                return ConeClassLikeLookupTagImpl(readOnlyId)
+                return readOnlyId.toLookupTag()
             }
         }
         MutabilityQualifier.MUTABLE -> {
             val mutableId = classId.readOnlyToMutable()
             if (position == TypeComponentPosition.FLEXIBLE_UPPER && mutableId != null) {
-                return ConeClassLikeLookupTagImpl(mutableId)
+                return mutableId.toLookupTag()
             }
         }
         null -> {}

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

@@ -154,7 +154,7 @@ private fun buildEnumCall(session: FirSession, classId: ClassId?, entryName: Nam
         if (classId != null) {
             this.typeRef = buildResolvedTypeRef {
                 type = ConeClassLikeTypeImpl(
-                    ConeClassLikeLookupTagImpl(classId),
+                    classId.toLookupTag(),
                     emptyArray(),
                     isNullable = false
                 )
@@ -174,7 +174,7 @@ private fun List<JavaAnnotationArgument>.mapJavaTargetArguments(session: FirSess
         resultSet.mapTo(arguments) { buildEnumCall(session, classId, Name.identifier(it.name)) }
         varargElementType = buildResolvedTypeRef {
             type = ConeClassLikeTypeImpl(
-                ConeClassLikeLookupTagImpl(classId),
+                classId.toLookupTag(),
                 emptyArray(),
                 isNullable = false,
                 ConeAttributes.Empty
@@ -221,7 +221,7 @@ private fun JavaAnnotation.toFirAnnotationCall(
             StandardClassIds.Annotations.Java.Documented -> StandardClassIds.Annotations.MustBeDocumented
             StandardClassIds.Annotations.Java.Deprecated -> StandardClassIds.Annotations.Deprecated
             else -> classId
-        }?.let(::ConeClassLikeLookupTagImpl)
+        }?.toLookupTag()
         annotationTypeRef = if (lookupTag != null) {
             buildResolvedTypeRef {
                 type = ConeClassLikeTypeImpl(lookupTag, emptyArray(), isNullable = false)

compiler/fir/plugin-utils/src/org/jetbrains/kotlin/fir/plugin/TypeUtils.kt

@@ -6,13 +6,10 @@
 package org.jetbrains.kotlin.fir.plugin
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.types.constructType
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
-import org.jetbrains.kotlin.fir.types.constructStarProjectedType
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.ConeTypeProjection
+import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.name.ClassId
 
@@ -29,7 +26,7 @@ public fun ClassId.createConeType(
             else -> symbol.constructType(typeArguments, nullable)
         }
         else -> ConeClassLikeTypeImpl(
-            ConeClassLikeLookupTagImpl(this),
+            this.toLookupTag(),
             typeArguments,
             nullable
         )

compiler/fir/providers/src/org/jetbrains/kotlin/fir/FirVisibilityChecker.kt

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.types.constructStarProjectedType
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.ClassId
@@ -390,7 +389,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
         val ownerSymbol = toSymbol(session) as? FirRegularClassSymbol
 
         if (ownerSymbol?.fir?.isCompanion == true) {
-            return ConeClassLikeLookupTagImpl(outerClassId)
+            return outerClassId.toLookupTag()
         }
         return null
     }
@@ -546,7 +545,7 @@ fun FirClassLikeSymbol<*>.getContainingClassLookupTag(): ConeClassLikeLookupTag?
         (fir as? FirRegularClass)?.containingClassForLocal()
     } else {
         val ownerId = classId.outerClassId
-        ownerId?.let { ConeClassLikeLookupTagImpl(it) }
+        ownerId?.let { it.toLookupTag() }
     }
 }
 

compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt

@@ -89,7 +89,7 @@ fun ConeKotlinType.withParameterNameAnnotation(parameter: FirFunctionTypeParamet
             buildResolvedTypeRef {
                 source = fakeSource
                 type = ConeClassLikeTypeImpl(
-                    ConeClassLikeLookupTagImpl(StandardNames.FqNames.parameterNameClassId),
+                    StandardNames.FqNames.parameterNameClassId.toLookupTag(),
                     emptyArray(),
                     isNullable = false
                 )

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

@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirTypeIntersectionScope
 import org.jetbrains.kotlin.fir.scopes.impl.dynamicMembersStorage
 import org.jetbrains.kotlin.fir.scopes.impl.getOrBuildScopeForIntegerConstantOperatorType
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
@@ -151,7 +150,7 @@ fun FirClass.defaultType(): ConeClassLikeType =
 
 fun ClassId.defaultType(parameters: List<FirTypeParameterSymbol>): ConeClassLikeType =
     ConeClassLikeTypeImpl(
-        ConeClassLikeLookupTagImpl(this),
+        this.toLookupTag(),
         parameters.map {
             ConeTypeParameterTypeImpl(
                 it.toLookupTag(),

compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirDynamicScope.kt

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.create
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
+import org.jetbrains.kotlin.fir.types.toLookupTag
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.StandardClassIds
@@ -126,7 +127,7 @@ class FirDynamicMembersStorage(val session: FirSession) : FirSessionComponent {
 
     private val anyArrayTypeRef = buildResolvedTypeRef {
         type = ConeClassLikeTypeImpl(
-            ConeClassLikeLookupTagImpl(StandardClassIds.Array),
+            StandardClassIds.Array.toLookupTag(),
             arrayOf(session.builtinTypes.nullableAnyType.coneType),
             isNullable = false
         )

compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/InferenceUtils.kt

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -104,7 +103,7 @@ fun ConeKotlinType.kFunctionTypeToFunctionType(session: FirSession): ConeClassLi
         if (isSuspendOrKSuspendFunctionType(session)) FunctionClassKind.SuspendFunction
         else FunctionClassKind.Function
     val functionalTypeId = ClassId(kind.packageFqName, kind.numberedClassName(typeArguments.size - 1))
-    return ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(functionalTypeId), typeArguments, isNullable = false)
+    return ConeClassLikeTypeImpl(functionalTypeId.toLookupTag(), typeArguments, isNullable = false)
 }
 
 fun ConeKotlinType.suspendFunctionTypeToFunctionType(session: FirSession): ConeClassLikeType {
@@ -113,7 +112,7 @@ fun ConeKotlinType.suspendFunctionTypeToFunctionType(session: FirSession): ConeC
         if (isKFunctionType(session)) FunctionClassKind.KFunction
         else FunctionClassKind.Function
     val functionalTypeId = ClassId(kind.packageFqName, kind.numberedClassName(typeArguments.size - 1))
-    return ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(functionalTypeId), typeArguments, isNullable = false, attributes = attributes)
+    return ConeClassLikeTypeImpl(functionalTypeId.toLookupTag(), typeArguments, isNullable = false, attributes = attributes)
 }
 
 fun ConeKotlinType.suspendFunctionTypeToFunctionTypeWithContinuation(session: FirSession, continuationClassId: ClassId): ConeClassLikeType {
@@ -126,8 +125,8 @@ fun ConeKotlinType.suspendFunctionTypeToFunctionTypeWithContinuation(session: Fi
     val functionalTypeId = ClassId(kind.packageFqName, kind.numberedClassName(typeArguments.size))
     val lastTypeArgument = typeArguments.last()
     return ConeClassLikeTypeImpl(
-        ConeClassLikeLookupTagImpl(functionalTypeId),
-        typeArguments = (typeArguments.dropLast(1) + ConeClassLikeLookupTagImpl(continuationClassId).constructClassType(
+        functionalTypeId.toLookupTag(),
+        typeArguments = (typeArguments.dropLast(1) + continuationClassId.toLookupTag().constructClassType(
             arrayOf(lastTypeArgument),
             isNullable = false
         ) + lastTypeArgument).toTypedArray(),

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

@@ -161,7 +161,7 @@ fun createFunctionalType(
         else -> ConeAttributes.Empty
     }
     return ConeClassLikeTypeImpl(
-        ConeClassLikeLookupTagImpl(functionalTypeId),
+        functionalTypeId.toLookupTag(),
         receiverAndParameterTypes.toTypedArray(),
         isNullable = false,
         attributes = attributes
@@ -175,7 +175,7 @@ fun createKPropertyType(
 ): ConeLookupTagBasedType {
     val arguments = if (receiverType != null) listOf(receiverType, rawReturnType) else listOf(rawReturnType)
     val classId = StandardClassIds.reflectByName("K${if (isMutable) "Mutable" else ""}Property${arguments.size - 1}")
-    return ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(classId), arguments.toTypedArray(), isNullable = false)
+    return ConeClassLikeTypeImpl(classId.toLookupTag(), arguments.toTypedArray(), isNullable = false)
 }
 
 fun BodyResolveComponents.buildResolvedQualifierForClass(

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt

@@ -259,12 +259,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
                     session
                 )
 
-                val actualTypeParametersCount =
-                    when (symbol) {
-                        is FirTypeAliasSymbol ->
-                            outerDeclarations.sumOf { it?.let { d -> getActualTypeParametersCount(d) } ?: 0 }
-                        else -> symbol.typeParameterSymbols.size
-                    }
+                val actualTypeParametersCount = symbol.typeParameterSymbols.size
 
                 for ((typeParameterIndex, typeParameter) in originalTypeParameters.withIndex()) {
                     val (parameterClass, qualifierPartIndex) = typeParametersAlignedToQualifierParts[typeParameter.symbol] ?: continue

compiler/fir/tree/src/org/jetbrains/kotlin/fir/EnumClassUtils.kt

@@ -23,12 +23,12 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.builder.buildEmptyExpressionBlock
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
+import org.jetbrains.kotlin.fir.types.toLookupTag
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.StandardClassIds
@@ -44,7 +44,7 @@ fun FirRegularClassBuilder.generateValuesFunction(
         returnTypeRef = buildResolvedTypeRef {
             source = sourceElement
             type = ConeClassLikeTypeImpl(
-                ConeClassLikeLookupTagImpl(StandardClassIds.Array),
+                StandardClassIds.Array.toLookupTag(),
                 arrayOf(
                     ConeClassLikeTypeImpl(this@generateValuesFunction.symbol.toLookupTag(), emptyArray(), isNullable = false)
                 ),
@@ -97,7 +97,7 @@ fun FirRegularClassBuilder.generateValueOfFunction(
             returnTypeRef = buildResolvedTypeRef {
                 source = sourceElement
                 type = ConeClassLikeTypeImpl(
-                    ConeClassLikeLookupTagImpl(StandardClassIds.String),
+                    StandardClassIds.String.toLookupTag(),
                     emptyArray(),
                     isNullable = false
                 )
@@ -131,7 +131,7 @@ fun FirRegularClassBuilder.generateEntriesGetter(
         returnTypeRef = buildResolvedTypeRef {
             source = sourceElement
             type = ConeClassLikeTypeImpl(
-                ConeClassLikeLookupTagImpl(StandardClassIds.EnumEntries),
+                StandardClassIds.EnumEntries.toLookupTag(),
                 arrayOf(
                     ConeClassLikeTypeImpl(this@generateEntriesGetter.symbol.toLookupTag(), emptyArray(), isNullable = false)
                 ),

compiler/fir/tree/src/org/jetbrains/kotlin/fir/Primitives.kt

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.fir
 
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.utils.classId
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
+import org.jetbrains.kotlin.fir.types.toLookupTag
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.StandardClassIds
 
@@ -29,7 +29,7 @@ object StandardTypes {
 }
 
 private fun ClassId.createType(isNullable: Boolean = false): ConeClassLikeType =
-    ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(this), emptyArray(), isNullable)
+    ConeClassLikeTypeImpl(this.toLookupTag(), emptyArray(), isNullable)
 
 fun ConeClassLikeType.isDouble(): Boolean = lookupTag.classId == StandardClassIds.Double
 fun ConeClassLikeType.isFloat(): Boolean = lookupTag.classId == StandardClassIds.Float

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.coneType
+import org.jetbrains.kotlin.fir.types.toLookupTag
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.SpecialNames
@@ -50,7 +51,7 @@ sealed class FirClassLikeSymbol<D : FirClassLikeDeclaration>(
 sealed class FirClassSymbol<C : FirClass>(classId: ClassId) : FirClassLikeSymbol<C>(classId) {
     private val lookupTag: ConeClassLikeLookupTag =
         if (classId.isLocal) ConeClassLookupTagWithFixedSymbol(classId, this)
-        else ConeClassLikeLookupTagImpl(classId)
+        else classId.toLookupTag()
 
     override fun toLookupTag(): ConeClassLikeLookupTag = lookupTag
 
@@ -89,7 +90,7 @@ val ANONYMOUS_CLASS_ID = ClassId(FqName.ROOT, FqName.topLevel(SpecialNames.ANONY
 class FirAnonymousObjectSymbol : FirClassSymbol<FirAnonymousObject>(ANONYMOUS_CLASS_ID)
 
 class FirTypeAliasSymbol(classId: ClassId) : FirClassLikeSymbol<FirTypeAlias>(classId) {
-    override fun toLookupTag(): ConeClassLikeLookupTag = ConeClassLikeLookupTagImpl(classId)
+    override fun toLookupTag(): ConeClassLikeLookupTag = classId.toLookupTag()
 
     val resolvedExpandedTypeRef: FirResolvedTypeRef
         get() {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/ConeIntegerLiteralTypeImpl.kt

@@ -9,8 +9,6 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.isLong
 import org.jetbrains.kotlin.fir.isULong
-import org.jetbrains.kotlin.name.StandardClassIds
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.types.ConeIntegerLiteralTypeExtensions.approximateIntegerLiteralBounds
 import org.jetbrains.kotlin.fir.types.ConeIntegerLiteralTypeExtensions.createClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeIntegerLiteralTypeExtensions.createSupertypeList
@@ -18,6 +16,7 @@ import org.jetbrains.kotlin.fir.types.ConeIntegerLiteralTypeExtensions.getApprox
 import org.jetbrains.kotlin.fir.types.ConeIntegerLiteralTypeExtensions.withNullabilityAndAttributes
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.types.AbstractTypeChecker
 import org.jetbrains.kotlin.types.model.SimpleTypeMarker
 
@@ -85,7 +84,7 @@ class ConeIntegerLiteralConstantTypeImpl(
         }
 
         private fun createType(classId: ClassId): ConeClassLikeType {
-            return ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(classId), emptyArray(), false)
+            return ConeClassLikeTypeImpl(classId.toLookupTag(), emptyArray(), false)
         }
 
         private val INT_RANGE = Int.MIN_VALUE.toLong()..Int.MAX_VALUE.toLong()
@@ -143,12 +142,12 @@ private object ConeIntegerLiteralTypeExtensions {
     fun createSupertypeList(type: ConeIntegerLiteralType): List<ConeClassLikeType> {
         return listOf(
             createClassLikeType(StandardClassIds.Number),
-            ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(StandardClassIds.Comparable), arrayOf(ConeKotlinTypeProjectionIn(type)), false)
+            ConeClassLikeTypeImpl(StandardClassIds.Comparable.toLookupTag(), arrayOf(ConeKotlinTypeProjectionIn(type)), false)
         )
     }
 
     fun createClassLikeType(classId: ClassId): ConeClassLikeType {
-        return ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(classId), emptyArray(), false)
+        return ConeClassLikeTypeImpl(classId.toLookupTag(), emptyArray(), false)
     }
 
     fun ConeIntegerLiteralType.getApproximatedTypeImpl(expectedType: ConeKotlinType?): ConeClassLikeType {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/TypeConstructionUtils.kt

@@ -33,12 +33,16 @@ fun ConeClassLikeLookupTag.constructClassType(
     return ConeClassLikeTypeImpl(this, typeArguments, isNullable, attributes)
 }
 
+fun ClassId.toLookupTag(): ConeClassLikeLookupTagImpl {
+    return ConeClassLikeLookupTagImpl(this)
+}
+
 fun ClassId.constructClassLikeType(
     typeArguments: Array<out ConeTypeProjection>,
     isNullable: Boolean,
     attributes: ConeAttributes = ConeAttributes.Empty
 ): ConeClassLikeType {
-    return ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(this), typeArguments, isNullable, attributes)
+    return ConeClassLikeTypeImpl(this.toLookupTag(), typeArguments, isNullable, attributes)
 }
 
 fun FirClassifierSymbol<*>.constructType(

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

@@ -5,16 +5,10 @@
 
 package org.jetbrains.kotlin.fir.types.impl
 
-import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.KtSourceElement
-import org.jetbrains.kotlin.fakeElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.ConeTypeProjection
-import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.name.ClassId
@@ -29,7 +23,7 @@ sealed class FirImplicitBuiltinTypeRef(
     override val annotations: List<FirAnnotation>
         get() = emptyList()
 
-    override val type: ConeClassLikeType = ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(id), typeArguments, isNullable)
+    override val type: ConeClassLikeType = ConeClassLikeTypeImpl(id.toLookupTag(), typeArguments, isNullable)
 
     override val delegatedTypeRef: FirTypeRef?
         get() = null

plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/types/FirNumberSignAttributeExtension.kt

@@ -10,12 +10,8 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
 import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping
 import org.jetbrains.kotlin.fir.extensions.FirTypeAttributeExtension
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
-import org.jetbrains.kotlin.fir.types.ConeAttribute
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.classId
-import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -46,7 +42,7 @@ class FirNumberSignAttributeExtension(session: FirSession) : FirTypeAttributeExt
         return buildAnnotation {
             annotationTypeRef = buildResolvedTypeRef {
                 type = ConeClassLikeTypeImpl(
-                    ConeClassLikeLookupTagImpl(classId),
+                    classId.toLookupTag(),
                     emptyArray(),
                     isNullable = false
                 )

plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/diagnostics/FirParcelizeAnnotationChecker.kt

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.fromPrimaryConstructor
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.name.ClassId
@@ -123,7 +122,7 @@ object FirParcelizeAnnotationChecker : FirAnnotationCallChecker() {
         val targetType = (context.annotationContainers.lastOrNull() as? FirTypeRef)?.coneType?.withAttributes(ConeAttributes.Empty)
             ?: return
         val expectedType = ConeClassLikeTypeImpl(
-            ConeClassLikeLookupTagImpl(ParcelizeNames.PARCELER_ID),
+            ParcelizeNames.PARCELER_ID.toLookupTag(),
             arrayOf(targetType),
             isNullable = false
         )

plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/diagnostics/FirParcelizeClassChecker.kt

@@ -16,13 +16,9 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.types.classId
-import org.jetbrains.kotlin.fir.types.coneType
-import org.jetbrains.kotlin.fir.types.toRegularClassSymbol
+import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
-import org.jetbrains.kotlin.fir.types.isSubtypeOf
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.parcelize.ParcelizeNames.CREATOR_NAME
 import org.jetbrains.kotlin.parcelize.ParcelizeNames.OLD_PARCELER_ID
@@ -81,7 +77,7 @@ object FirParcelizeClassChecker : FirClassChecker() {
             val superTypeRef = klass.superTypeRefs[index]
             val superType = superTypeRef.coneType
             val parcelableType = ConeClassLikeTypeImpl(
-                ConeClassLikeLookupTagImpl(PARCELABLE_ID),
+                PARCELABLE_ID.toLookupTag(),
                 emptyArray(),
                 isNullable = false
             )