FIR rename: FirType -> FirTypeRef and related

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

@@ -25,10 +25,10 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.ConeKotlinTypeProjection
-import org.jetbrains.kotlin.fir.types.FirResolvedType
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeImpl
+import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.structure.*
@@ -49,7 +49,7 @@ class JavaSymbolProvider(
     private fun JavaAnnotation.toFirAnnotationCall(): FirAnnotationCall {
         return FirAnnotationCallImpl(
             session, psi = null, useSiteTarget = null,
-            annotationType = FirResolvedTypeImpl(
+            annotationTypeRef = FirResolvedTypeRefImpl(
                 session = session,
                 psi = null,
                 type = ConeClassTypeImpl(FirClassSymbol(classId!!), emptyArray()),
@@ -86,7 +86,7 @@ class JavaSymbolProvider(
         }
     }
 
-    private fun JavaClassifierType.toFirResolvedType(): FirResolvedType {
+    private fun JavaClassifierType.toFirResolvedTypeRef(): FirResolvedTypeRef {
         val coneType = when (val classifier = classifier) {
             is JavaClass -> {
                 val symbol = session.service<FirSymbolProvider>().getClassLikeSymbolByFqName(classifier.classId!!) as ConeClassSymbol
@@ -100,15 +100,15 @@ class JavaSymbolProvider(
             }
             else -> ConeClassErrorType(reason = "Unexpected classifier: $classifier")
         }
-        return FirResolvedTypeImpl(
+        return FirResolvedTypeRefImpl(
             session, psi = null, type = coneType,
             isMarkedNullable = false, annotations = annotations.map { it.toFirAnnotationCall() }
         )
     }
 
-    private fun JavaType.toFirResolvedType(): FirResolvedType {
-        if (this is JavaClassifierType) return toFirResolvedType()
-        return FirResolvedTypeImpl(
+    private fun JavaType.toFirResolvedTypeRef(): FirResolvedTypeRef {
+        if (this is JavaClassifierType) return toFirResolvedTypeRef()
+        return FirResolvedTypeRefImpl(
             session, psi = null, type = ConeClassErrorType("Unexpected JavaType: $this"),
             isMarkedNullable = false, annotations = emptyList()
         )
@@ -116,7 +116,7 @@ class JavaSymbolProvider(
 
     private fun JavaType.toConeProjection(): ConeKotlinTypeProjection {
         if (this is JavaClassifierType) {
-            return toFirResolvedType().type
+            return toFirResolvedTypeRef().type
         }
         return ConeClassErrorType("Unexpected type argument: $this")
     }
@@ -154,7 +154,7 @@ class JavaSymbolProvider(
                             isExpect = false, isActual = false, isOverride = false,
                             isOperator = true, isInfix = false, isInline = false,
                             isTailRec = false, isExternal = false, isSuspend = false,
-                            receiverType = null, returnType = javaMethod.returnType.toFirResolvedType()
+                            receiverTypeRef = null, returnTypeRef = javaMethod.returnType.toFirResolvedTypeRef()
                         ).apply {
                             for (typeParameter in javaMethod.typeParameters) {
                                 typeParameters += createTypeParameterSymbol(typeParameter.name).fir
@@ -163,7 +163,7 @@ class JavaSymbolProvider(
                             for (valueParameter in javaMethod.valueParameters) {
                                 valueParameters += FirValueParameterImpl(
                                     session, null, valueParameter.name ?: Name.special("<anonymous Java parameter>"),
-                                    returnType = valueParameter.type.toFirResolvedType(),
+                                    returnTypeRef = valueParameter.type.toFirResolvedTypeRef(),
                                     defaultValue = null, isCrossinline = false, isNoinline = false,
                                     isVararg = valueParameter.isVararg
                                 )
@@ -209,7 +209,7 @@ class JavaSymbolProvider(
                     }
                     addAnnotationsFrom(javaClass)
                     for (supertype in javaClass.supertypes) {
-                        superTypes += supertype.toFirResolvedType()
+                        superTypeRefs += supertype.toFirResolvedTypeRef()
                     }
                 }
             }

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt

@@ -17,8 +17,8 @@ import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirExplicitThisReference
 import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference
-import org.jetbrains.kotlin.fir.types.FirType
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeImpl
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
@@ -263,7 +263,7 @@ internal fun generateDestructuringBlock(
     multiDeclaration: KtDestructuringDeclaration,
     container: FirNamedDeclaration,
     extractAnnotationsTo: KtAnnotated.(FirAbstractAnnotatedElement) -> Unit,
-    toFirOrImplicitType: KtTypeReference?.() -> FirType
+    toFirOrImplicitTypeRef: KtTypeReference?.() -> FirTypeRef
 ): FirExpression {
     return FirBlockImpl(session, multiDeclaration).apply {
         if (container is FirVariable) {
@@ -273,7 +273,7 @@ internal fun generateDestructuringBlock(
         for ((index, entry) in multiDeclaration.entries.withIndex()) {
             statements += FirVariableImpl(
                 session, entry, entry.nameAsSafeName,
-                entry.typeReference.toFirOrImplicitType(), isVar,
+                entry.typeReference.toFirOrImplicitTypeRef(), isVar,
                 FirComponentCallImpl(session, entry, index + 1).apply {
                     arguments += generateAccessExpression(session, entry, container.name)
                 }
@@ -286,7 +286,7 @@ internal fun generateDestructuringBlock(
 
 internal fun generateTemporaryVariable(
     session: FirSession, psi: PsiElement?, name: Name, initializer: FirExpression
-): FirVariable = FirVariableImpl(session, psi, name, FirImplicitTypeImpl(session, psi), false, initializer)
+): FirVariable = FirVariableImpl(session, psi, name, FirImplicitTypeRefImpl(session, psi), false, initializer)
 
 internal fun generateTemporaryVariable(
     session: FirSession, psi: PsiElement?, specialName: String, initializer: FirExpression

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.references.FirExplicitThisReference
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.impl.*
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
@@ -41,11 +41,11 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
 
 class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
 
-    private val implicitUnitType = FirImplicitUnitType(session, null)
+    private val implicitUnitType = FirImplicitUnitTypeRef(session, null)
 
-    private val implicitAnyType = FirImplicitAnyType(session, null)
+    private val implicitAnyType = FirImplicitAnyTypeRef(session, null)
 
-    private val implicitEnumType = FirImplicitEnumType(session, null)
+    private val implicitEnumType = FirImplicitEnumTypeRef(session, null)
 
     fun buildFirFile(file: KtFile): FirFile {
         return file.accept(Visitor(), Unit) as FirFile
@@ -80,14 +80,14 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
         private inline fun <reified R : FirElement> KtElement.convert(): R =
             this.accept(this@Visitor, Unit) as R
 
-        private fun KtTypeReference?.toFirOrImplicitType(): FirType =
-            convertSafe() ?: FirImplicitTypeImpl(session, this)
+        private fun KtTypeReference?.toFirOrImplicitType(): FirTypeRef =
+            convertSafe() ?: FirImplicitTypeRefImpl(session, this)
 
-        private fun KtTypeReference?.toFirOrUnitType(): FirType =
+        private fun KtTypeReference?.toFirOrUnitType(): FirTypeRef =
             convertSafe() ?: implicitUnitType
 
-        private fun KtTypeReference?.toFirOrErrorType(): FirType =
-            convertSafe() ?: FirErrorTypeImpl(session, this, if (this == null) "Incomplete code" else "Conversion failed")
+        private fun KtTypeReference?.toFirOrErrorType(): FirTypeRef =
+            convertSafe() ?: FirErrorTypeRefImpl(session, this, if (this == null) "Incomplete code" else "Conversion failed")
 
         // Here we accept lambda as receiver to prevent expression calculation in stub mode
         private fun (() -> KtExpression?).toFirExpression(errorReason: String): FirExpression =
@@ -190,14 +190,14 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
 
         private fun KtPropertyAccessor?.toFirPropertyAccessor(
             property: KtProperty,
-            propertyType: FirType,
+            propertyTypeRef: FirTypeRef,
             isGetter: Boolean
         ): FirPropertyAccessor {
             if (this == null) {
                 return if (isGetter) {
-                    FirDefaultPropertyGetter(session, property, propertyType, property.visibility)
+                    FirDefaultPropertyGetter(session, property, propertyTypeRef, property.visibility)
                 } else {
-                    FirDefaultPropertySetter(session, property, propertyType, property.visibility)
+                    FirDefaultPropertySetter(session, property, propertyTypeRef, property.visibility)
                 }
             }
             val firAccessor = FirPropertyAccessorImpl(
@@ -206,30 +206,30 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
                 isGetter,
                 visibility,
                 if (isGetter) {
-                    returnTypeReference?.convertSafe() ?: propertyType
+                    returnTypeReference?.convertSafe() ?: propertyTypeRef
                 } else {
                     returnTypeReference.toFirOrUnitType()
                 }
             )
             firFunctions += firAccessor
             extractAnnotationsTo(firAccessor)
-            extractValueParametersTo(firAccessor, propertyType)
+            extractValueParametersTo(firAccessor, propertyTypeRef)
             if (!isGetter && firAccessor.valueParameters.isEmpty()) {
-                firAccessor.valueParameters += FirDefaultSetterValueParameter(session, this, propertyType)
+                firAccessor.valueParameters += FirDefaultSetterValueParameter(session, this, propertyTypeRef)
             }
             firAccessor.body = this.buildFirBody()
             firFunctions.removeLast()
             return firAccessor
         }
 
-        private fun KtParameter.toFirValueParameter(defaultType: FirType? = null): FirValueParameter {
+        private fun KtParameter.toFirValueParameter(defaultTypeRef: FirTypeRef? = null): FirValueParameter {
             val firValueParameter = FirValueParameterImpl(
                 session,
                 this,
                 nameAsSafeName,
                 when {
                     typeReference != null -> typeReference.toFirOrErrorType()
-                    defaultType != null -> defaultType
+                    defaultTypeRef != null -> defaultTypeRef
                     else -> null.toFirOrErrorType()
                 },
                 if (hasDefaultValue()) {
@@ -258,8 +258,8 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
                 isOverride = hasModifier(KtTokens.OVERRIDE_KEYWORD),
                 isConst = false,
                 isLateInit = false,
-                receiverType = null,
-                returnType = type,
+                receiverTypeRef = null,
+                returnTypeRef = type,
                 isVar = isMutable,
                 initializer = null,
                 getter = FirDefaultPropertyGetter(session, this, type, visibility),
@@ -284,10 +284,10 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
 
         private fun KtDeclarationWithBody.extractValueParametersTo(
             container: FirFunction,
-            defaultType: FirType? = null
+            defaultTypeRef: FirTypeRef? = null
         ) {
             for (valueParameter in valueParameters) {
-                (container.valueParameters as MutableList<FirValueParameter>) += valueParameter.toFirValueParameter(defaultType)
+                (container.valueParameters as MutableList<FirValueParameter>) += valueParameter.toFirValueParameter(defaultTypeRef)
             }
         }
 
@@ -298,58 +298,58 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
         }
 
         private fun KtClassOrObject.extractSuperTypeListEntriesTo(
-            container: FirModifiableClass, delegatedSelfType: FirType
-        ): FirType? {
+            container: FirModifiableClass, delegatedSelfTypeRef: FirTypeRef
+        ): FirTypeRef? {
             var superTypeCallEntry: KtSuperTypeCallEntry? = null
-            var delegatedSuperType: FirType? = null
+            var delegatedSuperTypeRef: FirTypeRef? = null
             for (superTypeListEntry in superTypeListEntries) {
                 when (superTypeListEntry) {
                     is KtSuperTypeEntry -> {
-                        container.superTypes += superTypeListEntry.typeReference.toFirOrErrorType()
+                        container.superTypeRefs += superTypeListEntry.typeReference.toFirOrErrorType()
                     }
                     is KtSuperTypeCallEntry -> {
-                        delegatedSuperType = superTypeListEntry.calleeExpression.typeReference.toFirOrErrorType()
-                        container.superTypes += delegatedSuperType
+                        delegatedSuperTypeRef = superTypeListEntry.calleeExpression.typeReference.toFirOrErrorType()
+                        container.superTypeRefs += delegatedSuperTypeRef
                         superTypeCallEntry = superTypeListEntry
                     }
                     is KtDelegatedSuperTypeEntry -> {
                         val type = superTypeListEntry.typeReference.toFirOrErrorType()
-                        container.superTypes += FirDelegatedTypeImpl(
+                        container.superTypeRefs += FirDelegatedTypeRefImpl(
                             type,
                             { superTypeListEntry.delegateExpression }.toFirExpression("Should have delegate")
                         )
                     }
                 }
             }
-            if (this is KtClass && this.isInterface()) return delegatedSuperType
+            if (this is KtClass && this.isInterface()) return delegatedSuperTypeRef
 
             fun isEnum() = this is KtClass && this.isEnum()
             // TODO: in case we have no primary constructor,
             // it may be not possible to determine delegated super type right here
-            delegatedSuperType = delegatedSuperType ?: (if (isEnum()) implicitEnumType else implicitAnyType)
-            if (!this.hasPrimaryConstructor()) return delegatedSuperType
+            delegatedSuperTypeRef = delegatedSuperTypeRef ?: (if (isEnum()) implicitEnumType else implicitAnyType)
+            if (!this.hasPrimaryConstructor()) return delegatedSuperTypeRef
 
             val firPrimaryConstructor = primaryConstructor.toFirConstructor(
                 superTypeCallEntry,
-                delegatedSuperType,
-                delegatedSelfType,
+                delegatedSuperTypeRef,
+                delegatedSelfTypeRef,
                 owner = this
             )
             container.declarations += firPrimaryConstructor
-            return delegatedSuperType
+            return delegatedSuperTypeRef
         }
 
         private fun KtPrimaryConstructor?.toFirConstructor(
             superTypeCallEntry: KtSuperTypeCallEntry?,
-            delegatedSuperType: FirType,
-            delegatedSelfType: FirType,
+            delegatedSuperTypeRef: FirTypeRef,
+            delegatedSelfTypeRef: FirTypeRef,
             owner: KtClassOrObject
         ): FirConstructor {
             val constructorCallee = superTypeCallEntry?.calleeExpression
             val firDelegatedCall = FirDelegatedConstructorCallImpl(
                 session,
                 constructorCallee ?: (this ?: owner),
-                delegatedSuperType,
+                delegatedSuperTypeRef,
                 isThis = false
             ).apply {
                 if (!stubMode) {
@@ -363,7 +363,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
                 this?.visibility ?: Visibilities.UNKNOWN,
                 this?.hasExpectModifier() ?: false,
                 this?.hasActualModifier() ?: false,
-                delegatedSelfType,
+                delegatedSelfTypeRef,
                 firDelegatedCall
             )
             this?.extractAnnotationsTo(firConstructor)
@@ -394,8 +394,8 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
             return firFile
         }
 
-        private fun KtClassOrObject.toDelegatedSelfType(): FirType =
-            FirUserTypeImpl(session, this, isNullable = false).apply {
+        private fun KtClassOrObject.toDelegatedSelfType(): FirTypeRef =
+            FirUserTypeRefImpl(session, this, isNullable = false).apply {
                 qualifier.add(FirQualifierPartImpl(nameAsSafeName))
             }
 
@@ -548,7 +548,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
             } else {
                 typeReference.toFirOrImplicitType()
             }
-            val receiverType = function.receiverTypeReference.convertSafe<FirType>()
+            val receiverType = function.receiverTypeReference.convertSafe<FirTypeRef>()
             val firFunction = if (function.name == null) {
                 FirAnonymousFunctionImpl(session, function, returnType, receiverType)
             } else {
@@ -587,8 +587,8 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
 
         override fun visitLambdaExpression(expression: KtLambdaExpression, data: Unit): FirElement {
             val literal = expression.functionLiteral
-            val returnType = FirImplicitTypeImpl(session, literal)
-            val receiverType = FirImplicitTypeImpl(session, literal)
+            val returnType = FirImplicitTypeRefImpl(session, literal)
+            val receiverType = FirImplicitTypeRefImpl(session, literal)
             return FirAnonymousFunctionImpl(session, literal, returnType, receiverType).apply {
                 firFunctions += this
                 var destructuringBlock: FirExpression? = null
@@ -597,7 +597,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
                     valueParameters += if (multiDeclaration != null) {
                         val multiParameter = FirValueParameterImpl(
                             session, valueParameter, Name.special("<destruct>"),
-                            FirImplicitTypeImpl(session, multiDeclaration),
+                            FirImplicitTypeRefImpl(session, multiDeclaration),
                             defaultValue = null, isCrossinline = false, isNoinline = false, isVararg = false
                         )
                         destructuringBlock = generateDestructuringBlock(
@@ -624,8 +624,8 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
         }
 
         private fun KtSecondaryConstructor.toFirConstructor(
-            delegatedSuperType: FirType?,
-            delegatedSelfType: FirType,
+            delegatedSuperTypeRef: FirTypeRef?,
+            delegatedSelfTypeRef: FirTypeRef,
             hasPrimaryConstructor: Boolean
         ): FirConstructor {
             val firConstructor = FirConstructorImpl(
@@ -635,8 +635,8 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
                 visibility,
                 hasExpectModifier(),
                 hasActualModifier(),
-                delegatedSelfType,
-                getDelegationCall().convert(delegatedSuperType, delegatedSelfType, hasPrimaryConstructor)
+                delegatedSelfTypeRef,
+                getDelegationCall().convert(delegatedSuperTypeRef, delegatedSelfTypeRef, hasPrimaryConstructor)
             )
             firFunctions += firConstructor
             extractAnnotationsTo(firConstructor)
@@ -647,14 +647,14 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
         }
 
         private fun KtConstructorDelegationCall.convert(
-            delegatedSuperType: FirType?,
-            delegatedSelfType: FirType,
+            delegatedSuperTypeRef: FirTypeRef?,
+            delegatedSelfTypeRef: FirTypeRef,
             hasPrimaryConstructor: Boolean
         ): FirDelegatedConstructorCall {
             val isThis = isCallToThis || (isImplicit && hasPrimaryConstructor)
             val delegatedType = when {
-                isThis -> delegatedSelfType
-                else -> delegatedSuperType ?: FirErrorTypeImpl(session, this, "No super type")
+                isThis -> delegatedSelfTypeRef
+                else -> delegatedSuperTypeRef ?: FirErrorTypeRefImpl(session, this, "No super type")
             }
             return FirDelegatedConstructorCallImpl(
                 session,
@@ -732,11 +732,11 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
 
             val unwrappedElement = typeElement.unwrapNullable()
             val firType = when (unwrappedElement) {
-                is KtDynamicType -> FirDynamicTypeImpl(session, typeReference, isNullable)
+                is KtDynamicType -> FirDynamicTypeRefImpl(session, typeReference, isNullable)
                 is KtUserType -> {
                     var referenceExpression = unwrappedElement.referenceExpression
                     if (referenceExpression != null) {
-                        val userType = FirUserTypeImpl(
+                        val userType = FirUserTypeRefImpl(
                             session, typeReference, isNullable
                         )
                         var qualifier: KtUserType? = unwrappedElement
@@ -755,11 +755,11 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
 
                         userType
                     } else {
-                        FirErrorTypeImpl(session, typeReference, "Incomplete user type")
+                        FirErrorTypeRefImpl(session, typeReference, "Incomplete user type")
                     }
                 }
                 is KtFunctionType -> {
-                    val functionType = FirFunctionTypeImpl(
+                    val functionType = FirFunctionTypeRefImpl(
                         session,
                         typeReference,
                         isNullable,
@@ -772,7 +772,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
                     }
                     functionType
                 }
-                null -> FirErrorTypeImpl(session, typeReference, "Unwrapped type is null")
+                null -> FirErrorTypeRefImpl(session, typeReference, "Unwrapped type is null")
                 else -> throw AssertionError("Unexpected type element: ${unwrappedElement.text}")
             }
 
@@ -806,7 +806,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
             parameter.extractAnnotationsTo(firTypeParameter)
             val extendsBound = parameter.extendsBound
             if (extendsBound != null) {
-                firTypeParameter.bounds += extendsBound.convert<FirType>()
+                firTypeParameter.bounds += extendsBound.convert<FirTypeRef>()
             }
             val owner = parameter.getStrictParentOfType<KtTypeParameterListOwner>() ?: return firTypeParameter
             for (typeConstraint in owner.typeConstraints) {

compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.FirSessionBase
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
@@ -126,7 +126,7 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
         override fun visitElement(element: FirElement) {
             // NB: types are reused sometimes (e.g. in accessors)
             if (!result.add(element)) {
-                if (element !is FirType) {
+                if (element !is FirTypeRef) {
                     val elementDump = StringBuilder().also { element.accept(FirRenderer(it)) }.toString()
                     throw AssertionError("FirElement ${element.javaClass} is visited twice: $elementDump")
                 }
@@ -141,7 +141,7 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
 
         override fun <E : FirElement> transformElement(element: E, data: Unit): CompositeTransformResult<E> {
             if (!result.add(element)) {
-                if (element !is FirType) {
+                if (element !is FirTypeRef) {
                     val elementDump = StringBuilder().also { element.accept(FirRenderer(it)) }.toString()
                     throw AssertionError("FirElement ${element.javaClass} is visited twice: $elementDump")
                 }

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

@@ -10,18 +10,18 @@ import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.ConeSymbol
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.fir.types.FirUserType
+import org.jetbrains.kotlin.fir.types.FirUserTypeRef
 
 interface FirTypeResolver {
 
-    fun resolveType(type: FirType, scope: FirScope, position: FirPosition): ConeKotlinType
-    fun resolveToSymbol(type: FirType, scope: FirScope, position: FirPosition): ConeSymbol?
+    fun resolveType(typeRef: FirTypeRef, scope: FirScope, position: FirPosition): ConeKotlinType
+    fun resolveToSymbol(typeRef: FirTypeRef, scope: FirScope, position: FirPosition): ConeSymbol?
 
     companion object {
         fun getInstance(session: FirSession): FirTypeResolver = session.service()
     }
 
-    fun resolveUserType(type: FirUserType, symbol: ConeSymbol?, scope: FirScope): ConeKotlinType
+    fun resolveUserType(typeRef: FirUserTypeRef, symbol: ConeSymbol?, scope: FirScope): ConeKotlinType
 }

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

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.FictitiousFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeImpl
+import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
 import org.jetbrains.kotlin.metadata.deserialization.Flags
@@ -112,9 +112,9 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider
                         typeDeserializer.classLikeType(supertypeProto)
                     }// TODO: + c.components.additionalClassPartsProvider.getSupertypes(this@DeserializedClassDescriptor)
 
-                    superTypesDeserialized.mapNotNullTo(superTypes) {
+                    superTypesDeserialized.mapNotNullTo(superTypeRefs) {
                         if (it == null) return@mapNotNullTo null
-                        FirResolvedTypeImpl(session, null, it, false, emptyList())
+                        FirResolvedTypeRefImpl(session, null, it, false, emptyList())
                     }
                     // TODO: declarations (probably should be done later)
                 }

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

@@ -26,7 +26,7 @@ class FirTypeResolverImpl : FirTypeResolver {
             when (it) {
                 is FirStarProjection -> StarProjection
                 is FirTypeProjectionWithVariance -> {
-                    val type = (it.type as FirResolvedType).type
+                    val type = (it.typeRef as FirResolvedTypeRef).type
                     when (it.variance) {
                         Variance.INVARIANT -> type
                         Variance.IN_VARIANCE -> ConeKotlinTypeProjectionIn(type)
@@ -63,28 +63,28 @@ class FirTypeResolverImpl : FirTypeResolver {
     private val implicitBuiltinTypeSymbols = mutableMapOf<NameInSession, ConeSymbol>()
 
     override fun resolveToSymbol(
-        type: FirType,
+        typeRef: FirTypeRef,
         scope: FirScope,
         position: FirPosition
     ): ConeSymbol? {
-        return when (type) {
-            is FirResolvedType -> type.coneTypeSafe<ConeSymbolBasedType>()?.symbol
-            is FirUserType -> {
+        return when (typeRef) {
+            is FirResolvedTypeRef -> typeRef.coneTypeSafe<ConeSymbolBasedType>()?.symbol
+            is FirUserTypeRef -> {
 
-                val qualifierResolver = FirQualifierResolver.getInstance(type.session)
+                val qualifierResolver = FirQualifierResolver.getInstance(typeRef.session)
 
                 var resolvedSymbol: ConeSymbol? = null
-                scope.processClassifiersByName(type.qualifier.first().name, position) { symbol ->
+                scope.processClassifiersByName(typeRef.qualifier.first().name, position) { symbol ->
                     resolvedSymbol = when (symbol) {
                         is ConeClassLikeSymbol -> {
-                            if (type.qualifier.size == 1) {
+                            if (typeRef.qualifier.size == 1) {
                                 symbol
                             } else {
-                                qualifierResolver.resolveSymbolWithPrefix(type.qualifier, symbol.classId)
+                                qualifierResolver.resolveSymbolWithPrefix(typeRef.qualifier, symbol.classId)
                             }
                         }
                         is ConeTypeParameterSymbol -> {
-                            assert(type.qualifier.size == 1)
+                            assert(typeRef.qualifier.size == 1)
                             symbol
                         }
                         else -> error("!")
@@ -93,13 +93,13 @@ class FirTypeResolverImpl : FirTypeResolver {
                 }
 
                 // TODO: Imports
-                resolvedSymbol ?: qualifierResolver.resolveSymbol(type.qualifier)
+                resolvedSymbol ?: qualifierResolver.resolveSymbol(typeRef.qualifier)
             }
-            is FirImplicitBuiltinType -> {
-                val nameInSession = NameInSession(type.session, type.name)
+            is FirImplicitBuiltinTypeRef -> {
+                val nameInSession = NameInSession(typeRef.session, typeRef.name)
                 implicitBuiltinTypeSymbols[nameInSession] ?: run {
                     var resolvedSymbol: ConeSymbol? = null
-                    scope.processClassifiersByName(type.name, position) {
+                    scope.processClassifiersByName(typeRef.name, position) {
                         resolvedSymbol = (it as ConeClassLikeSymbol)
                         resolvedSymbol == null
                     }
@@ -111,36 +111,36 @@ class FirTypeResolverImpl : FirTypeResolver {
         }
     }
 
-    override fun resolveUserType(type: FirUserType, symbol: ConeSymbol?, scope: FirScope): ConeKotlinType {
+    override fun resolveUserType(typeRef: FirUserTypeRef, symbol: ConeSymbol?, scope: FirScope): ConeKotlinType {
         symbol ?: return ConeKotlinErrorType("Symbol not found")
-        return symbol.toConeKotlinType(type.qualifier) ?: ConeKotlinErrorType("Failed to resolve qualified type")
+        return symbol.toConeKotlinType(typeRef.qualifier) ?: ConeKotlinErrorType("Failed to resolve qualified type")
     }
 
     override fun resolveType(
-        type: FirType,
+        typeRef: FirTypeRef,
         scope: FirScope,
         position: FirPosition
     ): ConeKotlinType {
-        return when (type) {
-            is FirResolvedType -> type.type
-            is FirUserType -> {
-                resolveUserType(type, resolveToSymbol(type, scope, position), scope)
+        return when (typeRef) {
+            is FirResolvedTypeRef -> typeRef.type
+            is FirUserTypeRef -> {
+                resolveUserType(typeRef, resolveToSymbol(typeRef, scope, position), scope)
             }
-            is FirErrorType -> {
-                ConeKotlinErrorType(type.reason)
+            is FirErrorTypeRef -> {
+                ConeKotlinErrorType(typeRef.reason)
             }
-            is FirFunctionType -> {
+            is FirFunctionTypeRef -> {
                 ConeFunctionTypeImpl(
-                    (type.receiverType as FirResolvedType?)?.type,
-                    type.valueParameters.map { it.returnType.coneTypeUnsafe<ConeKotlinType>() },
-                    type.returnType.coneTypeUnsafe()
+                    (typeRef.receiverTypeRef as FirResolvedTypeRef?)?.type,
+                    typeRef.valueParameters.map { it.returnTypeRef.coneTypeUnsafe<ConeKotlinType>() },
+                    typeRef.returnTypeRef.coneTypeUnsafe()
                 )
             }
-            is FirImplicitBuiltinType -> {
-                resolveToSymbol(type, scope, position)!!.toConeKotlinType(emptyList())!!
+            is FirImplicitBuiltinTypeRef -> {
+                resolveToSymbol(typeRef, scope, position)!!.toConeKotlinType(emptyList())!!
             }
-            is FirDynamicType, is FirImplicitType, is FirDelegatedType -> {
-                ConeKotlinErrorType("Not supported: ${type::class.simpleName}")
+            is FirDynamicTypeRef, is FirImplicitTypeRef, is FirDelegatedTypeRef -> {
+                ConeKotlinErrorType("Not supported: ${typeRef::class.simpleName}")
             }
             else -> error("!")
         }

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

@@ -19,9 +19,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedFunctionTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeImpl
+import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
+import org.jetbrains.kotlin.fir.types.impl.FirResolvedFunctionTypeRefImpl
+import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.compose
@@ -109,39 +109,39 @@ open class FirTypeResolveTransformer(
         }
     }
 
-    override fun transformType(type: FirType, data: Nothing?): CompositeTransformResult<FirType> {
-        val typeResolver = FirTypeResolver.getInstance(type.session)
-        type.transformChildren(this, null)
-        return transformType(type, typeResolver.resolveType(type, towerScope, position = FirPosition.OTHER))
+    override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        val typeResolver = FirTypeResolver.getInstance(typeRef.session)
+        typeRef.transformChildren(this, null)
+        return transformType(typeRef, typeResolver.resolveType(typeRef, towerScope, position = FirPosition.OTHER))
     }
 
-    override fun transformFunctionType(functionType: FirFunctionType, data: Nothing?): CompositeTransformResult<FirType> {
-        val typeResolver = FirTypeResolver.getInstance(functionType.session)
-        functionType.transformChildren(this, data)
-        return FirResolvedFunctionTypeImpl(
-            functionType.psi,
-            functionType.session,
-            functionType.isMarkedNullable,
-            functionType.annotations as MutableList<FirAnnotationCall>,
-            functionType.receiverType,
-            functionType.valueParameters as MutableList<FirValueParameter>,
-            functionType.returnType,
-            typeResolver.resolveType(functionType, towerScope, FirPosition.OTHER)
+    override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        val typeResolver = FirTypeResolver.getInstance(functionTypeRef.session)
+        functionTypeRef.transformChildren(this, data)
+        return FirResolvedFunctionTypeRefImpl(
+            functionTypeRef.psi,
+            functionTypeRef.session,
+            functionTypeRef.isMarkedNullable,
+            functionTypeRef.annotations as MutableList<FirAnnotationCall>,
+            functionTypeRef.receiverTypeRef,
+            functionTypeRef.valueParameters as MutableList<FirValueParameter>,
+            functionTypeRef.returnTypeRef,
+            typeResolver.resolveType(functionTypeRef, towerScope, FirPosition.OTHER)
         ).compose()
     }
 
-    private fun transformType(type: FirType, resolvedType: ConeKotlinType): CompositeTransformResult<FirType> {
-        return FirResolvedTypeImpl(
-            type.session,
-            type.psi,
+    private fun transformType(typeRef: FirTypeRef, resolvedType: ConeKotlinType): CompositeTransformResult<FirTypeRef> {
+        return FirResolvedTypeRefImpl(
+            typeRef.session,
+            typeRef.psi,
             resolvedType,
             false,
-            type.annotations
+            typeRef.annotations
         ).compose()
     }
 
-    override fun transformResolvedType(resolvedType: FirResolvedType, data: Nothing?): CompositeTransformResult<FirType> {
-        return resolvedType.compose()
+    override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return resolvedTypeRef.compose()
     }
 
     override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult<FirDeclaration> {
@@ -180,10 +180,10 @@ open class FirTypeResolveTransformer(
 
                     if (symbol is ConeTypeAliasSymbol) {
                         val fir = symbol.fir as FirTypeAlias
-                        if (fir.expandedType is FirResolvedType) return
+                        if (fir.expandedTypeRef is FirResolvedTypeRef) return
                     } else if (symbol is ConeClassSymbol) {
                         val fir = symbol.fir as FirClass
-                        if (fir.superTypes.all { it is FirResolvedType }) return
+                        if (fir.superTypeRefs.all { it is FirResolvedTypeRef }) return
                     }
                     val firProvider = FirProvider.getInstance(symbol.fir.session)
                     val classes = generateSequence(classId) { it.outerClassId }.toList().asReversed()
@@ -209,24 +209,24 @@ open class FirTypeResolveTransformer(
             }
         }
 
-        override fun transformType(type: FirType, data: Nothing?): CompositeTransformResult<FirType> {
-            val typeResolver = FirTypeResolver.getInstance(type.session)
-            val symbol = typeResolver.resolveToSymbol(type, towerScope, position = FirPosition.SUPER_TYPE_OR_EXPANSION)
+        override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+            val typeResolver = FirTypeResolver.getInstance(typeRef.session)
+            val symbol = typeResolver.resolveToSymbol(typeRef, towerScope, position = FirPosition.SUPER_TYPE_OR_EXPANSION)
             val myTransformer = this@FirTypeResolveTransformer
 
             if (symbol != null) {
                 if (symbol is AbstractFirBasedSymbol<*> && symbol.fir in traversedClassifiers) {
-                    return FirErrorTypeImpl(type.session, type.psi, "Recursion detected: ${type.render()}").compose()
+                    return FirErrorTypeRefImpl(typeRef.session, typeRef.psi, "Recursion detected: ${typeRef.render()}").compose()
                 } else {
                     walkSymbols(symbol)
                 }
             }
 
-            if (type !is FirUserType) return type.transform(myTransformer, data)
+            if (typeRef !is FirUserTypeRef) return typeRef.transform(myTransformer, data)
 
 
-            type.transformChildren(myTransformer, null)
-            return myTransformer.transformType(type, typeResolver.resolveUserType(type, symbol, towerScope))
+            typeRef.transformChildren(myTransformer, null)
+            return myTransformer.transformType(typeRef, typeResolver.resolveUserType(typeRef, symbol, towerScope))
         }
     }
 }

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 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.FirResolvedTypeImpl
+import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.name.Name
 
 class FirClassSubstitutionScope(
@@ -97,14 +97,14 @@ class FirClassSubstitutionScope(
         name: Name
     ): FirFunctionSymbol {
         val member = (original as FirBasedSymbol<*>).fir as? FirNamedFunction ?: error("Can't fake override for $original")
-        val receiverType = member.receiverType?.coneTypeUnsafe()
+        val receiverType = member.receiverTypeRef?.coneTypeUnsafe()
         val newReceiverType = receiverType?.substitute()
 
-        val returnType = member.returnType.coneTypeUnsafe()
+        val returnType = member.returnTypeRef.coneTypeUnsafe()
         val newReturnType = returnType.substitute()
 
         val newParameterTypes = member.valueParameters.map {
-            it.returnType.coneTypeUnsafe().substitute()
+            it.returnTypeRef.coneTypeUnsafe().substitute()
         }
 
         val symbol = FirFunctionSymbol(original.callableId, true)
@@ -116,15 +116,15 @@ class FirClassSubstitutionScope(
                 psi,
                 symbol,
                 name,
-                member.receiverType?.withReplacedConeType(newReceiverType),
-                member.returnType.withReplacedConeType(newReturnType)
+                member.receiverTypeRef?.withReplacedConeType(newReceiverType),
+                member.returnTypeRef.withReplacedConeType(newReturnType)
             ).apply {
                 status = member.status as FirDeclarationStatusImpl
                 valueParameters += member.valueParameters.zip(newParameterTypes) { valueParameter, newType ->
                     with(valueParameter) {
                         FirValueParameterImpl(
                             session, psi,
-                            name, this.returnType.withReplacedConeType(newType),
+                            name, this.returnTypeRef.withReplacedConeType(newType),
                             defaultValue, isCrossinline, isNoinline, isVararg
                         )
                     }
@@ -136,11 +136,11 @@ class FirClassSubstitutionScope(
 }
 
 
-fun FirType.withReplacedConeType(newType: ConeKotlinType?): FirResolvedType {
-    require(this is FirResolvedType)
+fun FirTypeRef.withReplacedConeType(newType: ConeKotlinType?): FirResolvedTypeRef {
+    require(this is FirResolvedTypeRef)
     if (newType == null) return this
 
-    return FirResolvedTypeImpl(
+    return FirResolvedTypeRefImpl(
         session, psi, newType,
         isMarkedNullable,
         annotations

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

@@ -20,8 +20,8 @@ import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.fir.types.FirResolvedType
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.addToStdlib.cast
 
@@ -40,8 +40,8 @@ class FirClassUseSiteScope(
         return true
     }
 
-    private fun isSubtypeOf(subType: FirType, superType: FirType) =
-        isSubtypeOf(subType.cast<FirResolvedType>().type, superType.cast<FirResolvedType>().type)
+    private fun isSubtypeOf(subType: FirTypeRef, superType: FirTypeRef) =
+        isSubtypeOf(subType.cast<FirResolvedTypeRef>().type, superType.cast<FirResolvedTypeRef>().type)
 
     @Suppress("UNUSED_PARAMETER")
     private fun isEqualTypes(a: ConeKotlinType, b: ConeKotlinType): Boolean {
@@ -49,22 +49,22 @@ class FirClassUseSiteScope(
         return true
     }
 
-    private fun isEqualTypes(a: FirType, b: FirType) = isEqualTypes(a.cast<FirResolvedType>().type, b.cast<FirResolvedType>().type)
+    private fun isEqualTypes(a: FirTypeRef, b: FirTypeRef) = isEqualTypes(a.cast<FirResolvedTypeRef>().type, b.cast<FirResolvedTypeRef>().type)
 
     private fun isOverriddenFunCheck(member: FirNamedFunction, self: FirNamedFunction): Boolean {
         return member.valueParameters.size == self.valueParameters.size &&
                 member.valueParameters.zip(self.valueParameters).all { (memberParam, selfParam) ->
-                    isEqualTypes(memberParam.returnType, selfParam.returnType)
+                    isEqualTypes(memberParam.returnTypeRef, selfParam.returnTypeRef)
                 }
     }
 
     private fun ConeCallableSymbol.isOverridden(seen: Set<ConeCallableSymbol>): ConeCallableSymbol? {
         if (overrides.containsKey(this)) return overrides[this]
 
-        fun sameReceivers(memberType: FirType?, selfType: FirType?): Boolean {
+        fun sameReceivers(memberTypeRef: FirTypeRef?, selfTypeRef: FirTypeRef?): Boolean {
             return when {
-                memberType != null && selfType != null -> isEqualTypes(memberType, selfType)
-                else -> memberType == null && selfType == null
+                memberTypeRef != null && selfTypeRef != null -> isEqualTypes(memberTypeRef, selfTypeRef)
+                else -> memberTypeRef == null && selfTypeRef == null
             }
         }
 
@@ -81,8 +81,8 @@ class FirClassUseSiteScope(
         val overriding = seen.firstOrNull {
             val member = (it as AbstractFirBasedSymbol<*>).fir as FirCallableMember
             member.isOverride && self.modality != Modality.FINAL
-                    && sameReceivers(member.receiverType, self.receiverType)
-                    && isSubtypeOf(member.returnType, self.returnType)
+                    && sameReceivers(member.receiverTypeRef, self.receiverTypeRef)
+                    && isSubtypeOf(member.returnTypeRef, self.returnTypeRef)
                     && similarFunctionsOrBothProperties(member, self)
         } // TODO: two or more overrides for one fun?
         overrides[this] = overriding

compiler/fir/resolve/testData/resolve/fromBuilder/enums.txt

@@ -62,8 +62,8 @@ FILE: enums.kt
         public final companion object Companion {
             public constructor(): super<R|kotlin/Any|>()
 
-            public final const property G(val): R|error: Not supported: FirImplicitTypeImpl| = Double(6.67E-11)
-                public get(): R|error: Not supported: FirImplicitTypeImpl|
+            public final const property G(val): R|error: Not supported: FirImplicitTypeRefImpl| = Double(6.67E-11)
+                public get(): R|error: Not supported: FirImplicitTypeRefImpl|
 
         }
 

compiler/fir/resolve/testData/resolve/fromBuilder/simpleClass.txt

@@ -9,8 +9,8 @@ FILE: simpleClass.kt
     public final class SomeClass : R|SomeInterface| {
         public constructor(): super<R|kotlin/Any|>()
 
-        private final property baz(val): R|error: Not supported: FirImplicitTypeImpl| = Int(42)
-            private get(): R|error: Not supported: FirImplicitTypeImpl|
+        private final property baz(val): R|error: Not supported: FirImplicitTypeRefImpl| = Int(42)
+            private get(): R|error: Not supported: FirImplicitTypeRefImpl|
 
         public final override function foo(x: R|kotlin/Int|, y: R|kotlin/String|): R|kotlin/String| {
             return@@@foo <Unresolved name: plus>#(<Unresolved name: plus>#(<Unresolved name: y>#, <Unresolved name: x>#), R|/SomeClass.baz|)

compiler/fir/resolve/testData/resolve/references/simple.txt

@@ -1,7 +1,7 @@
 FILE: simple.kt
-    public final function foo(): R|error: Not supported: FirImplicitTypeImpl| {
+    public final function foo(): R|error: Not supported: FirImplicitTypeRefImpl| {
         return@@@foo Int(1)
     }
-    public final function bar(): R|error: Not supported: FirImplicitTypeImpl| {
+    public final function bar(): R|error: Not supported: FirImplicitTypeRefImpl| {
         return@@@bar R|/foo|()
     }

compiler/fir/resolve/testData/resolve/simpleClass.txt

@@ -9,8 +9,8 @@ FILE: simpleClass.kt
     public final class SomeClass : R|SomeInterface| {
         public constructor(): super<R|kotlin/Any|>()
 
-        private final property baz(val): R|error: Not supported: FirImplicitTypeImpl| = Int(42)
-            private get(): R|error: Not supported: FirImplicitTypeImpl|
+        private final property baz(val): R|error: Not supported: FirImplicitTypeRefImpl| = Int(42)
+            private get(): R|error: Not supported: FirImplicitTypeRefImpl|
 
         public final override function foo(x: R|kotlin/Int|, y: R|kotlin/String|): R|kotlin/String| {
             return@@@foo <Unresolved name: plus>#(<Unresolved name: plus>#(<Unresolved name: y>#, <Unresolved name: x>#), R|/SomeClass.baz|)

compiler/fir/resolve/testData/resolve/stdlib/functionX.txt

@@ -1,5 +1,5 @@
 FILE: functionX.kt
-    public final property x(val): R|kotlin/jvm/functions/Function0<kotlin/Int>| = function  R|error: Not supported: FirImplicitTypeImpl|.<anonymous>(): R|error: Not supported: FirImplicitTypeImpl| {
+    public final property x(val): R|kotlin/jvm/functions/Function0<kotlin/Int>| = function  R|error: Not supported: FirImplicitTypeRefImpl|.<anonymous>(): R|error: Not supported: FirImplicitTypeRefImpl| {
         return  {
             Int(42)
         }
@@ -7,7 +7,7 @@ FILE: functionX.kt
     }
 
         public get(): R|kotlin/jvm/functions/Function0<kotlin/Int>|
-    public final property y(val): R|kotlin/Function1<kotlin/String, kotlin/String>| = function  R|error: Not supported: FirImplicitTypeImpl|.<anonymous>(): R|error: Not supported: FirImplicitTypeImpl| {
+    public final property y(val): R|kotlin/Function1<kotlin/String, kotlin/String>| = function  R|error: Not supported: FirImplicitTypeRefImpl|.<anonymous>(): R|error: Not supported: FirImplicitTypeRefImpl| {
         return  {
             <Unresolved name: it>#
         }

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

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.symbols.ConeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinType
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.types.Variance
@@ -95,7 +95,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
 
     override fun visitCallableMember(callableMember: FirCallableMember) {
         visitMemberDeclaration(callableMember)
-        val receiverType = callableMember.receiverType
+        val receiverType = callableMember.receiverTypeRef
         if (receiverType != null) {
             print(" ")
             receiverType.accept(this)
@@ -107,7 +107,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
             print(if (callableMember.isVar) "(var)" else "(val)")
         }
         print(": ")
-        callableMember.returnType.accept(this)
+        callableMember.returnTypeRef.accept(this)
     }
 
     private fun Visibility.asString() =
@@ -222,9 +222,9 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
 
     override fun visitRegularClass(regularClass: FirRegularClass) {
         visitMemberDeclaration(regularClass)
-        if (regularClass.superTypes.isNotEmpty()) {
+        if (regularClass.superTypeRefs.isNotEmpty()) {
             print(" : ")
-            regularClass.superTypes.renderSeparated()
+            regularClass.superTypeRefs.renderSeparated()
         }
         regularClass.renderDeclarations()
     }
@@ -232,7 +232,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
     override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
         anonymousObject.annotations.renderAnnotations()
         print("object : ")
-        anonymousObject.superTypes.renderSeparated()
+        anonymousObject.superTypeRefs.renderSeparated()
         anonymousObject.renderDeclarations()
     }
 
@@ -240,7 +240,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         variable.annotations.renderAnnotations()
         visitNamedDeclaration(variable)
         print(": ")
-        variable.returnType.accept(this)
+        variable.returnTypeRef.accept(this)
         variable.initializer?.let {
             print(" = ")
             it.accept(this)
@@ -301,7 +301,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         print(if (propertyAccessor.isGetter) "get" else "set")
         propertyAccessor.valueParameters.renderParameters()
         print(": ")
-        propertyAccessor.returnType.accept(this)
+        propertyAccessor.returnTypeRef.accept(this)
         propertyAccessor.body?.accept(this)
     }
 
@@ -312,7 +312,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
             print("${label.name}@")
         }
         print("function ")
-        val receiverType = anonymousFunction.receiverType
+        val receiverType = anonymousFunction.receiverTypeRef
         if (receiverType != null) {
             print(" ")
             receiverType.accept(this)
@@ -321,7 +321,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         print("<anonymous>")
         anonymousFunction.valueParameters.renderParameters()
         print(": ")
-        anonymousFunction.returnType.accept(this)
+        anonymousFunction.returnTypeRef.accept(this)
         anonymousFunction.body?.accept(this)
     }
 
@@ -355,7 +355,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         typeAlias.annotations.renderAnnotations()
         visitMemberDeclaration(typeAlias)
         print(" = ")
-        typeAlias.expandedType.accept(this)
+        typeAlias.expandedTypeRef.accept(this)
         println()
     }
 
@@ -390,7 +390,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         if (valueParameter.name != SpecialNames.NO_NAME_PROVIDED) {
             print(valueParameter.name.toString() + ": ")
         }
-        valueParameter.returnType.accept(this)
+        valueParameter.returnTypeRef.accept(this)
         valueParameter.defaultValue?.let {
             print(" = ")
             it.accept(this)
@@ -542,7 +542,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
             print(it.name)
             print(":")
         }
-        annotationCall.annotationType.accept(this)
+        annotationCall.annotationTypeRef.accept(this)
         visitCall(annotationCall)
         if (annotationCall.useSiteTarget == AnnotationUseSiteTarget.FILE) {
             println()
@@ -557,54 +557,54 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         } else if (delegatedConstructorCall.isThis) {
             print(": this<")
         }
-        delegatedConstructorCall.constructedType.accept(this)
+        delegatedConstructorCall.constructedTypeRef.accept(this)
         print(">")
         visitCall(delegatedConstructorCall)
     }
 
-    override fun visitType(type: FirType) {
-        type.annotations.renderAnnotations()
-        visitElement(type)
+    override fun visitTypeRef(typeRef: FirTypeRef) {
+        typeRef.annotations.renderAnnotations()
+        visitElement(typeRef)
     }
 
-    override fun visitDelegatedType(delegatedType: FirDelegatedType) {
-        delegatedType.type.accept(this)
+    override fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef) {
+        delegatedTypeRef.typeRef.accept(this)
         print(" by ")
-        delegatedType.delegate?.accept(this)
+        delegatedTypeRef.delegate?.accept(this)
     }
 
-    override fun visitErrorType(errorType: FirErrorType) {
-        visitType(errorType)
-        print("<ERROR TYPE: ${errorType.reason}>")
+    override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {
+        visitTypeRef(errorTypeRef)
+        print("<ERROR TYPE: ${errorTypeRef.reason}>")
     }
 
-    override fun visitImplicitType(implicitType: FirImplicitType) {
-        print(if (implicitType is FirImplicitBuiltinType) "kotlin.${implicitType.name}" else "<implicit>")
+    override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) {
+        print(if (implicitTypeRef is FirImplicitBuiltinTypeRef) "kotlin.${implicitTypeRef.name}" else "<implicit>")
     }
 
-    override fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability) {
-        if (typeWithNullability.isMarkedNullable) {
+    override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) {
+        if (typeRefWithNullability.isMarkedNullable) {
             print("?")
         }
     }
 
-    override fun visitDynamicType(dynamicType: FirDynamicType) {
-        dynamicType.annotations.renderAnnotations()
+    override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) {
+        dynamicTypeRef.annotations.renderAnnotations()
         print("<dynamic>")
-        visitTypeWithNullability(dynamicType)
+        visitTypeRefWithNullability(dynamicTypeRef)
     }
 
-    override fun visitFunctionType(functionType: FirFunctionType) {
+    override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) {
         print("( ")
-        functionType.receiverType?.let {
+        functionTypeRef.receiverTypeRef?.let {
             it.accept(this)
             print(".")
         }
-        functionType.valueParameters.renderParameters()
+        functionTypeRef.valueParameters.renderParameters()
         print(" -> ")
-        functionType.returnType.accept(this)
+        functionTypeRef.returnTypeRef.accept(this)
         print(" )")
-        visitTypeWithNullability(functionType)
+        visitTypeRefWithNullability(functionTypeRef)
     }
 
     private fun ConeSymbol.asString(): String {
@@ -654,18 +654,18 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         }
     }
 
-    override fun visitResolvedType(resolvedType: FirResolvedType) {
-        resolvedType.annotations.renderAnnotations()
+    override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
+        resolvedTypeRef.annotations.renderAnnotations()
         print("R|")
-        val coneType = resolvedType.type
+        val coneType = resolvedTypeRef.type
         print(coneType.asString())
         print("|")
-        visitTypeWithNullability(resolvedType)
+        visitTypeRefWithNullability(resolvedTypeRef)
     }
 
-    override fun visitUserType(userType: FirUserType) {
-        userType.annotations.renderAnnotations()
-        for ((index, qualifier) in userType.qualifier.withIndex()) {
+    override fun visitUserTypeRef(userTypeRef: FirUserTypeRef) {
+        userTypeRef.annotations.renderAnnotations()
+        for ((index, qualifier) in userTypeRef.qualifier.withIndex()) {
             if (index != 0) {
                 print(".")
             }
@@ -676,7 +676,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
                 print(">")
             }
         }
-        visitTypeWithNullability(userType)
+        visitTypeRefWithNullability(userTypeRef)
     }
 
     override fun visitTypeProjection(typeProjection: FirTypeProjection) {
@@ -685,7 +685,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
 
     override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance) {
         typeProjectionWithVariance.variance.renderVariance()
-        typeProjectionWithVariance.type.accept(this)
+        typeProjectionWithVariance.typeRef.accept(this)
     }
 
     override fun visitStarProjection(starProjection: FirStarProjection) {
@@ -722,7 +722,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
 
     override fun visitSuperReference(superReference: FirSuperReference) {
         print("super<")
-        superReference.superType.accept(this)
+        superReference.superTypeRef.accept(this)
         print(">")
     }
 
@@ -792,7 +792,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         print(operatorCall.operation.operator)
         if (operatorCall is FirTypeOperatorCall) {
             print("/")
-            operatorCall.type.accept(this)
+            operatorCall.typeRef.accept(this)
         }
         visitCall(operatorCall)
     }

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

@@ -5,16 +5,16 @@
 
 package org.jetbrains.kotlin.fir
 
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirSuperReference : FirReference {
-    val superType: FirType
+    val superTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitSuperReference(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        superType.accept(visitor, data)
+        superTypeRef.accept(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt

@@ -8,11 +8,11 @@ package org.jetbrains.kotlin.fir.declarations
 import org.jetbrains.kotlin.fir.FirLabeledElement
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirAnonymousFunction : @VisitedSupertype FirFunction, FirExpression, FirTypedDeclaration, FirLabeledElement {
-    val receiverType: FirType?
+    val receiverTypeRef: FirTypeRef?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitAnonymousFunction(this, data)
@@ -20,7 +20,7 @@ interface FirAnonymousFunction : @VisitedSupertype FirFunction, FirExpression, F
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         super<FirTypedDeclaration>.acceptChildren(visitor, data)
         super<FirLabeledElement>.acceptChildren(visitor, data)
-        receiverType?.accept(visitor, data)
+        receiverTypeRef?.accept(visitor, data)
         for (parameter in valueParameters) {
             parameter.accept(visitor, data)
         }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableMember.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 // Good name needed (something with receiver, type parameters, return type, and name)
@@ -16,14 +16,14 @@ interface FirCallableMember :
     FirTypedDeclaration, FirSymbolOwner<FirCallableMember> {
     val isOverride: Boolean get() = status.isOverride
 
-    val receiverType: FirType?
+    val receiverTypeRef: FirTypeRef?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitCallableMember(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        receiverType?.accept(visitor, data)
+        receiverTypeRef?.accept(visitor, data)
         super<FirMemberDeclaration>.acceptChildren(visitor, data)
-        returnType.accept(visitor, data)
+        returnTypeRef.accept(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt

@@ -9,13 +9,13 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirClass : FirDeclarationContainer, FirStatement, FirAnnotationContainer {
     // including delegated types
-    val superTypes: List<FirType>
+    val superTypeRefs: List<FirTypeRef>
 
     val classKind: ClassKind
 
@@ -23,7 +23,7 @@ interface FirClass : FirDeclarationContainer, FirStatement, FirAnnotationContain
         visitor.visitClass(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        for (superType in superTypes) {
+        for (superType in superTypeRefs) {
             superType.accept(visitor, data)
         }
         for (declaration in declarations) {
@@ -32,4 +32,4 @@ interface FirClass : FirDeclarationContainer, FirStatement, FirAnnotationContain
     }
 }
 
-val FirClass.superConeTypes get() = superTypes.mapNotNull { it.coneTypeSafe<ConeClassLikeType>() }
+val FirClass.superConeTypes get() = superTypeRefs.mapNotNull { it.coneTypeSafe<ConeClassLikeType>() }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt

@@ -7,21 +7,21 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirTypeAlias : FirMemberDeclaration, FirSymbolOwner<FirTypeAlias> {
-    val expandedType: FirType
+    val expandedTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitTypeAlias(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         super.acceptChildren(visitor, data)
-        expandedType.accept(visitor, data)
+        expandedTypeRef.accept(visitor, data)
     }
 }
 
 
-val FirTypeAlias.expandedConeType: ConeClassLikeType? get() = expandedType.coneTypeSafe()
+val FirTypeAlias.expandedConeType: ConeClassLikeType? get() = expandedTypeRef.coneTypeSafe()

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.BaseTransformedType
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.types.Variance
 
@@ -19,7 +19,7 @@ interface FirTypeParameter : FirNamedDeclaration, FirAnnotationContainer, FirSym
 
     val isReified: Boolean
 
-    val bounds: List<FirType>
+    val bounds: List<FirTypeRef>
 
     override val symbol: FirTypeParameterSymbol
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirTypedDeclaration : FirDeclaration, FirAnnotationContainer {
-    val returnType: FirType
+    val returnTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitTypedDeclaration(this, data)
@@ -18,6 +18,6 @@ interface FirTypedDeclaration : FirDeclaration, FirAnnotationContainer {
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         acceptAnnotations(visitor, data)
         super.acceptChildren(visitor, data)
-        returnType.accept(visitor, data)
+        returnTypeRef.accept(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractCallableMember.kt

@@ -13,28 +13,28 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirCallableMember
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
 abstract class FirAbstractCallableMember : FirAbstractMemberDeclaration, FirCallableMember {
 
     final override val symbol: FirBasedSymbol<FirCallableMember>
-    final override var receiverType: FirType?
-    final override var returnType: FirType
+    final override var receiverTypeRef: FirTypeRef?
+    final override var returnTypeRef: FirTypeRef
 
     constructor(
         session: FirSession,
         psi: PsiElement?,
         symbol: FirBasedSymbol<FirCallableMember>,
         name: Name,
-        receiverType: FirType?,
-        returnType: FirType
+        receiverTypeRef: FirTypeRef?,
+        returnTypeRef: FirTypeRef
     ) : super(session, psi, name) {
         this.symbol = symbol
         symbol.bind(this)
-        this.receiverType = receiverType
-        this.returnType = returnType
+        this.receiverTypeRef = receiverTypeRef
+        this.returnTypeRef = returnTypeRef
     }
 
     constructor(
@@ -47,20 +47,20 @@ abstract class FirAbstractCallableMember : FirAbstractMemberDeclaration, FirCall
         isExpect: Boolean,
         isActual: Boolean,
         isOverride: Boolean,
-        receiverType: FirType?,
-        returnType: FirType
+        receiverTypeRef: FirTypeRef?,
+        returnTypeRef: FirTypeRef
     ) : super(session, psi, name, visibility, modality, isExpect, isActual) {
         this.symbol = symbol
         symbol.bind(this)
-        this.receiverType = receiverType
-        this.returnType = returnType
+        this.receiverTypeRef = receiverTypeRef
+        this.returnTypeRef = returnTypeRef
         status.isOverride = isOverride
     }
 
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        receiverType = receiverType?.transformSingle(transformer, data)
-        returnType = returnType.transformSingle(transformer, data)
+        receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
+        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
 
         return super<FirAbstractMemberDeclaration>.transformChildren(transformer, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt

@@ -11,20 +11,20 @@ import org.jetbrains.kotlin.fir.FirLabel
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirAnonymousFunctionImpl(
     session: FirSession,
     psi: PsiElement?,
-    override var returnType: FirType,
-    override var receiverType: FirType?
+    override var returnTypeRef: FirTypeRef,
+    override var receiverTypeRef: FirTypeRef?
 ) : FirAbstractFunction(session, psi), FirAnonymousFunction, FirModifiableFunction {
     override var label: FirLabel? = null
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        returnType = returnType.transformSingle(transformer, data)
-        receiverType = receiverType?.transformSingle(transformer, data)
+        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
+        receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
         label = label?.transformSingle(transformer, data)
         return super<FirAbstractFunction>.transformChildren(transformer, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.transformInplace
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
@@ -19,7 +19,7 @@ class FirAnonymousObjectImpl(
     session: FirSession,
     psi: PsiElement?
 ) : FirAbstractAnnotatedDeclaration(session, psi), FirAnonymousObject, FirModifiableClass {
-    override val superTypes = mutableListOf<FirType>()
+    override val superTypeRefs = mutableListOf<FirTypeRef>()
 
     override val declarations = mutableListOf<FirDeclaration>()
 
@@ -28,7 +28,7 @@ class FirAnonymousObjectImpl(
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        superTypes.transformInplace(transformer, data)
+        superTypeRefs.transformInplace(transformer, data)
         declarations.transformInplace(transformer, data)
 
         return super<FirAbstractAnnotatedDeclaration>.transformChildren(transformer, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.transformInplace
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
@@ -42,13 +42,13 @@ open class FirClassImpl(
         status.isInline = isInline
     }
 
-    override val superTypes = mutableListOf<FirType>()
+    override val superTypeRefs = mutableListOf<FirTypeRef>()
 
     override val declarations = mutableListOf<FirDeclaration>()
 
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirRegularClass {
-        superTypes.transformInplace(transformer, data)
+        superTypeRefs.transformInplace(transformer, data)
         val result = super<FirAbstractMemberDeclaration>.transformChildren(transformer, data) as FirRegularClass
 
         // Transform declarations in last turn

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
@@ -28,11 +28,11 @@ open class FirConstructorImpl(
     visibility: Visibility,
     isExpect: Boolean,
     isActual: Boolean,
-    delegatedSelfType: FirType,
+    delegatedSelfTypeRef: FirTypeRef,
     final override var delegatedConstructor: FirDelegatedConstructorCall?
 ) : FirAbstractCallableMember(
     session, psi, symbol, NAME, visibility, Modality.FINAL,
-    isExpect, isActual, isOverride = false, receiverType = null, returnType = delegatedSelfType
+    isExpect, isActual, isOverride = false, receiverTypeRef = null, returnTypeRef = delegatedSelfTypeRef
 ), FirConstructor {
     override val valueParameters = mutableListOf<FirValueParameter>()
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt

@@ -16,8 +16,8 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 abstract class FirDefaultPropertyAccessor(
@@ -40,15 +40,15 @@ abstract class FirDefaultPropertyAccessor(
 class FirDefaultPropertyGetter(
     session: FirSession,
     psi: PsiElement?,
-    propertyType: FirType,
+    propertyTypeRef: FirTypeRef,
     visibility: Visibility
 ) : FirDefaultPropertyAccessor(session, psi, isGetter = true, visibility = visibility) {
     override val valueParameters: List<FirValueParameter> = emptyList()
 
-    override var returnType: FirType = propertyType
+    override var returnTypeRef: FirTypeRef = propertyTypeRef
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        returnType = returnType.transformSingle(transformer, data)
+        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         status = status.transformSingle(transformer, data)
 
         return this
@@ -58,16 +58,16 @@ class FirDefaultPropertyGetter(
 class FirDefaultPropertySetter(
     session: FirSession,
     psi: PsiElement?,
-    propertyType: FirType,
+    propertyTypeRef: FirTypeRef,
     visibility: Visibility
 ) : FirDefaultPropertyAccessor(session, psi, isGetter = false, visibility = visibility) {
-    override val valueParameters = mutableListOf(FirDefaultSetterValueParameter(session, psi, propertyType))
+    override val valueParameters = mutableListOf(FirDefaultSetterValueParameter(session, psi, propertyTypeRef))
 
-    override var returnType: FirType = FirImplicitUnitType(session, psi)
+    override var returnTypeRef: FirTypeRef = FirImplicitUnitTypeRef(session, psi)
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         valueParameters.transformInplace(transformer, data)
-        returnType = returnType.transformSingle(transformer, data)
+        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         status = status.transformSingle(transformer, data)
 
         return this

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt

@@ -11,14 +11,14 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
 class FirDefaultSetterValueParameter(
     session: FirSession,
     psi: PsiElement?,
-    override var returnType: FirType
+    override var returnTypeRef: FirTypeRef
 ) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirValueParameter {
     override val isCrossinline = false
 
@@ -29,7 +29,7 @@ class FirDefaultSetterValueParameter(
     override val defaultValue: FirExpression? = null
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        returnType = returnType.transformSingle(transformer, data)
+        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
 
         return super<FirAbstractNamedAnnotatedDeclaration>.transformChildren(transformer, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
@@ -27,9 +27,9 @@ class FirMemberFunctionImpl : FirAbstractCallableMember, FirNamedFunction, FirMo
         psi: PsiElement?,
         symbol: FirFunctionSymbol,
         name: Name,
-        receiverType: FirType?,
-        returnType: FirType
-    ) : super(session, psi, symbol, name, receiverType, returnType)
+        receiverTypeRef: FirTypeRef?,
+        returnTypeRef: FirTypeRef
+    ) : super(session, psi, symbol, name, receiverTypeRef, returnTypeRef)
 
     constructor(
         session: FirSession,
@@ -47,11 +47,11 @@ class FirMemberFunctionImpl : FirAbstractCallableMember, FirNamedFunction, FirMo
         isTailRec: Boolean,
         isExternal: Boolean,
         isSuspend: Boolean,
-        receiverType: FirType?,
-        returnType: FirType
+        receiverTypeRef: FirTypeRef?,
+        returnTypeRef: FirTypeRef
     ) : super(
         session, psi, symbol, name, visibility, modality,
-        isExpect, isActual, isOverride, receiverType, returnType
+        isExpect, isActual, isOverride, receiverTypeRef, returnTypeRef
     ) {
         status.isOperator = isOperator
         status.isInfix = isInfix

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
@@ -31,15 +31,15 @@ class FirMemberPropertyImpl(
     isOverride: Boolean,
     isConst: Boolean,
     isLateInit: Boolean,
-    receiverType: FirType?,
-    returnType: FirType,
+    receiverTypeRef: FirTypeRef?,
+    returnTypeRef: FirTypeRef,
     override val isVar: Boolean,
     override var initializer: FirExpression?,
     override var getter: FirPropertyAccessor,
     override var setter: FirPropertyAccessor,
     override var delegate: FirExpression?
 ) : FirAbstractCallableMember(
-    session, psi, symbol, name, visibility, modality, isExpect, isActual, isOverride, receiverType, returnType
+    session, psi, symbol, name, visibility, modality, isExpect, isActual, isOverride, receiverTypeRef, returnTypeRef
 ), FirProperty {
     init {
         status.isConst = isConst

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.fir.declarations.impl
 
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 
 interface FirModifiableClass : FirClass {
-    override val superTypes: MutableList<FirType>
+    override val superTypeRefs: MutableList<FirTypeRef>
 
     override val declarations: MutableList<FirDeclaration>
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructorImpl.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 
 class FirPrimaryConstructorImpl(
     session: FirSession,
@@ -19,6 +19,6 @@ class FirPrimaryConstructorImpl(
     visibility: Visibility,
     isExpect: Boolean,
     isActual: Boolean,
-    delegatedSelfType: FirType,
+    delegatedSelfTypeRef: FirTypeRef,
     delegatedConstructor: FirDelegatedConstructorCall?
-) : FirConstructorImpl(session, psi, symbol, visibility, isExpect, isActual, delegatedSelfType, delegatedConstructor)
+) : FirConstructorImpl(session, psi, symbol, visibility, isExpect, isActual, delegatedSelfTypeRef, delegatedConstructor)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt

@@ -11,9 +11,8 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
-import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirPropertyAccessorImpl(
@@ -21,14 +20,14 @@ class FirPropertyAccessorImpl(
     psi: PsiElement?,
     override val isGetter: Boolean,
     visibility: Visibility,
-    override var returnType: FirType
+    override var returnTypeRef: FirTypeRef
 ) : FirAbstractFunction(session, psi), FirPropertyAccessor {
     override var status = FirDeclarationStatusImpl(
         session, visibility, Modality.FINAL
     )
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        returnType = returnType.transformSingle(transformer, data)
+        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         status = status.transformSingle(transformer, data)
 
         return super<FirAbstractFunction>.transformChildren(transformer, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
@@ -25,7 +25,7 @@ class FirTypeAliasImpl(
     visibility: Visibility,
     isExpect: Boolean,
     isActual: Boolean,
-    override var expandedType: FirType
+    override var expandedTypeRef: FirTypeRef
 ) : FirAbstractMemberDeclaration(session, psi, name, visibility, Modality.FINAL, isExpect, isActual), FirTypeAlias {
 
     init {
@@ -33,7 +33,7 @@ class FirTypeAliasImpl(
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        expandedType = expandedType.transformSingle(transformer, data)
+        expandedTypeRef = expandedTypeRef.transformSingle(transformer, data)
 
         return super<FirAbstractMemberDeclaration>.transformChildren(transformer, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeParameterImpl.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.transformInplace
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance
@@ -28,7 +28,7 @@ class FirTypeParameterImpl(
         symbol.bind(this)
     }
 
-    override val bounds = mutableListOf<FirType>()
+    override val bounds = mutableListOf<FirTypeRef>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         bounds.transformInplace(transformer, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
@@ -19,14 +19,14 @@ class FirValueParameterImpl(
     session: FirSession,
     psi: PsiElement?,
     name: Name,
-    override var returnType: FirType,
+    override var returnTypeRef: FirTypeRef,
     override var defaultValue: FirExpression?,
     override val isCrossinline: Boolean,
     override val isNoinline: Boolean,
     override val isVararg: Boolean
 ) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirValueParameter {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        returnType = returnType.transformSingle(transformer, data)
+        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         defaultValue = defaultValue?.transformSingle(transformer, data)
 
         return super<FirAbstractNamedAnnotatedDeclaration>.transformChildren(transformer, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirVariableImpl.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirVariable
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
@@ -19,13 +19,13 @@ class FirVariableImpl(
     session: FirSession,
     psiElement: PsiElement?,
     name: Name,
-    override var returnType: FirType,
+    override var returnTypeRef: FirTypeRef,
     override val isVar: Boolean,
     override var initializer: FirExpression?,
     override var delegate: FirExpression? = null
 ) : FirAbstractNamedAnnotatedDeclaration(session, psiElement, name), FirVariable {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        returnType = returnType.transformSingle(transformer, data)
+        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         initializer = initializer?.transformSingle(transformer, data)
         delegate = delegate?.transformSingle(transformer, data)
 

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

@@ -7,12 +7,12 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.BaseTransformedType
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 @BaseTransformedType
 interface FirAnnotationCall : FirCall {
-    val annotationType: FirType
+    val annotationTypeRef: FirTypeRef
 
     // May be should be not-null (with correct default target)
     val useSiteTarget: AnnotationUseSiteTarget?
@@ -21,7 +21,7 @@ interface FirAnnotationCall : FirCall {
         visitor.visitAnnotationCall(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        annotationType.accept(visitor, data)
+        annotationTypeRef.accept(visitor, data)
         super.acceptChildren(visitor, data)
     }
 }

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

@@ -5,13 +5,12 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
-import org.jetbrains.kotlin.fir.types.FirType
-import org.jetbrains.kotlin.fir.types.FirTypeProjectionContainer
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirDelegatedConstructorCall : FirCall {
     // Do we need 'constructedType: FirType' here?
-    val constructedType: FirType
+    val constructedTypeRef: FirTypeRef
 
     val isThis: Boolean
 
@@ -22,7 +21,7 @@ interface FirDelegatedConstructorCall : FirCall {
         visitor.visitDelegatedConstructorCall(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        constructedType.accept(visitor, data)
+        constructedTypeRef.accept(visitor, data)
         super.acceptChildren(visitor, data)
     }
 }

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

@@ -5,20 +5,20 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 // is/!is/as/as?
 interface FirTypeOperatorCall : FirOperatorCall {
     val argument: FirExpression get() = arguments.first()
 
-    val type: FirType
+    val typeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitTypeOperatorCall(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        type.accept(visitor, data)
+        typeRef.accept(visitor, data)
         super.acceptChildren(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt

@@ -11,17 +11,17 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirAnnotationCallImpl(
     session: FirSession,
     psi: PsiElement?,
     override val useSiteTarget: AnnotationUseSiteTarget?,
-    override var annotationType: FirType
+    override var annotationTypeRef: FirTypeRef
 ) : FirAbstractCall(session, psi), FirAnnotationCall {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        annotationType = annotationType.transformSingle(transformer, data)
+        annotationTypeRef = annotationTypeRef.transformSingle(transformer, data)
 
         return super<FirAbstractCall>.transformChildren(transformer, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt

@@ -10,17 +10,17 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirDelegatedConstructorCallImpl(
     session: FirSession,
     psi: PsiElement?,
-    override var constructedType: FirType,
+    override var constructedTypeRef: FirTypeRef,
     override val isThis: Boolean
 ) : FirAbstractCall(session, psi), FirDelegatedConstructorCall {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        constructedType = constructedType.transformSingle(transformer, data)
+        constructedTypeRef = constructedTypeRef.transformSingle(transformer, data)
 
         return super<FirAbstractCall>.transformChildren(transformer, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirTypeOperatorCallImpl.kt

@@ -11,17 +11,17 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirOperation
 import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirTypeOperatorCallImpl(
     session: FirSession,
     psi: PsiElement?,
     override val operation: FirOperation,
-    override var type: FirType
+    override var typeRef: FirTypeRef
 ) : FirAbstractCall(session, psi), FirTypeOperatorCall {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        type = type.transformSingle(transformer, data)
+        typeRef = typeRef.transformSingle(transformer, data)
         return super<FirAbstractCall>.transformChildren(transformer, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirExplicitSuperReference.kt

@@ -7,16 +7,16 @@ package org.jetbrains.kotlin.fir.references
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirExplicitSuperReference(
     session: FirSession,
     psi: PsiElement?,
-    override var superType: FirType
+    override var superTypeRef: FirTypeRef
 ) : FirAbstractElement(session, psi), FirSuperReference {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        superType = superType.transformSingle(transformer, data)
+        superTypeRef = superTypeRef.transformSingle(transformer, data)
         return this
     }
 }

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

@@ -8,17 +8,17 @@ package org.jetbrains.kotlin.fir.types
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirDelegatedType : FirType {
+interface FirDelegatedTypeRef : FirTypeRef {
     val delegate: FirExpression?
 
-    val type: FirType
+    val typeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitDelegatedType(this, data)
+        visitor.visitDelegatedTypeRef(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         super.acceptChildren(visitor, data)
         delegate?.accept(visitor, data)
-        type.accept(visitor, data)
+        typeRef.accept(visitor, data)
     }
 }

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.types
 
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirDynamicType : FirTypeWithNullability {
+interface FirDynamicTypeRef : FirTypeRefWithNullability {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitDynamicType(this, data)
+        visitor.visitDynamicTypeRef(this, data)
 }

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

@@ -7,9 +7,9 @@ package org.jetbrains.kotlin.fir.types
 
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirErrorType : FirType {
+interface FirErrorTypeRef : FirTypeRef {
     val reason: String
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitErrorType(this, data)
+        visitor.visitErrorTypeRef(this, data)
 }

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

@@ -8,20 +8,20 @@ package org.jetbrains.kotlin.fir.types
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirFunctionType : FirTypeWithNullability {
-    val receiverType: FirType?
+interface FirFunctionTypeRef : FirTypeRefWithNullability {
+    val receiverTypeRef: FirTypeRef?
 
     // May be it should inherit FirFunction?
     val valueParameters: List<FirValueParameter>
 
-    val returnType: FirType
+    val returnTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitFunctionType(this, data)
+        visitor.visitFunctionTypeRef(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        receiverType?.accept(visitor, data)
-        returnType.accept(visitor, data)
+        receiverTypeRef?.accept(visitor, data)
+        returnTypeRef.accept(visitor, data)
         super.acceptChildren(visitor, data)
         for (parameter in valueParameters) {
             parameter.accept(visitor, data)

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.types
 
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirImplicitType : FirType {
+interface FirImplicitTypeRef : FirTypeRef {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitImplicitType(this, data)
+        visitor.visitImplicitTypeRef(this, data)
 }

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

@@ -8,17 +8,17 @@ package org.jetbrains.kotlin.fir.types
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirResolvedType : FirTypeWithNullability {
+interface FirResolvedTypeRef : FirTypeRefWithNullability {
     val type: ConeKotlinType
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitResolvedType(this, data)
+        visitor.visitResolvedTypeRef(this, data)
 }
 
-interface FirResolvedFunctionType : @VisitedSupertype FirResolvedType, FirFunctionType {
+interface FirResolvedFunctionTypeRef : @VisitedSupertype FirResolvedTypeRef, FirFunctionTypeRef {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitResolvedFunctionType(this, data)
+        visitor.visitResolvedFunctionTypeRef(this, data)
 }
 
-inline fun <reified T : ConeKotlinType> FirType.coneTypeUnsafe() = (this as FirResolvedType).type as T
-inline fun <reified T : ConeKotlinType> FirType.coneTypeSafe() = (this as? FirResolvedType)?.type as? T
+inline fun <reified T : ConeKotlinType> FirTypeRef.coneTypeUnsafe() = (this as FirResolvedTypeRef).type as T
+inline fun <reified T : ConeKotlinType> FirTypeRef.coneTypeSafe() = (this as? FirResolvedTypeRef)?.type as? T

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

@@ -11,13 +11,13 @@ import org.jetbrains.kotlin.types.Variance
 interface FirTypeProjectionWithVariance : FirTypeProjection {
     val variance: Variance
 
-    val type: FirType
+    val typeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitTypeProjectionWithVariance(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        type.accept(visitor, data)
+        typeRef.accept(visitor, data)
         super.acceptChildren(visitor, data)
     }
 }

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

@@ -11,9 +11,9 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 @BaseTransformedType
-interface FirType : FirElement, FirAnnotationContainer {
+interface FirTypeRef : FirElement, FirAnnotationContainer {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitType(this, data)
+        visitor.visitTypeRef(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         acceptAnnotations(visitor, data)

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

@@ -7,9 +7,9 @@ package org.jetbrains.kotlin.fir.types
 
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirTypeWithNullability : FirType {
+interface FirTypeRefWithNullability : FirTypeRef {
     val isMarkedNullable: Boolean
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitTypeWithNullability(this, data)
+        visitor.visitTypeRefWithNullability(this, data)
 }

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

@@ -12,11 +12,11 @@ interface FirQualifierPart : FirTypeProjectionContainer {
     val name: Name
 }
 
-interface FirUserType : FirTypeWithNullability {
+interface FirUserTypeRef : FirTypeRefWithNullability {
     val qualifier: List<FirQualifierPart>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitUserType(this, data)
+        visitor.visitUserTypeRef(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         super.acceptChildren(visitor, data)

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

@@ -10,14 +10,14 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.transformInplace
-import org.jetbrains.kotlin.fir.types.FirTypeWithNullability
+import org.jetbrains.kotlin.fir.types.FirTypeRefWithNullability
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-abstract class FirAbstractAnnotatedType(
+abstract class FirAbstractAnnotatedTypeRef(
     final override val session: FirSession,
     final override val psi: PsiElement?,
     final override val isMarkedNullable: Boolean
-) : FirTypeWithNullability {
+) : FirTypeRefWithNullability {
     override val annotations = mutableListOf<FirAnnotationCall>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {

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

@@ -10,19 +10,19 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirDelegatedType
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirDelegatedTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-class FirDelegatedTypeImpl(
-    override var type: FirType,
+class FirDelegatedTypeRefImpl(
+    override var typeRef: FirTypeRef,
     override var delegate: FirExpression?
-) : FirAbstractElement(type.session, type.psi), FirDelegatedType {
+) : FirAbstractElement(typeRef.session, typeRef.psi), FirDelegatedTypeRef {
     override val annotations: List<FirAnnotationCall>
-        get() = type.annotations
+        get() = typeRef.annotations
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        type = type.transformSingle(transformer, data)
+        typeRef = typeRef.transformSingle(transformer, data)
         delegate = delegate?.transformSingle(transformer, data)
 
         return this

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

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.fir.types.impl
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.types.FirDynamicType
+import org.jetbrains.kotlin.fir.types.FirDynamicTypeRef
 
-class FirDynamicTypeImpl(
+class FirDynamicTypeRefImpl(
     session: FirSession,
     psi: PsiElement?,
     isNullable: Boolean
-) : FirAbstractAnnotatedType(session, psi, isNullable), FirDynamicType
+) : FirAbstractAnnotatedTypeRef(session, psi, isNullable), FirDynamicTypeRef

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

@@ -7,15 +7,15 @@ package org.jetbrains.kotlin.fir.types.impl
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.types.FirErrorType
+import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-class FirErrorTypeImpl(
+class FirErrorTypeRefImpl(
     session: FirSession,
     psi: PsiElement?,
     override val reason: String
-) : FirAbstractAnnotatedType(session, psi, false), FirErrorType {
+) : FirAbstractAnnotatedTypeRef(session, psi, false), FirErrorTypeRef {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
-        return super<FirErrorType>.accept(visitor, data)
+        return super<FirErrorTypeRef>.accept(visitor, data)
     }
 }

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

@@ -11,24 +11,24 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirFunctionType
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirFunctionTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-class FirFunctionTypeImpl(
+class FirFunctionTypeRefImpl(
     session: FirSession,
     psi: PsiElement?,
     isNullable: Boolean,
-    override var receiverType: FirType?,
-    override var returnType: FirType
-) : FirAbstractAnnotatedType(session, psi, isNullable), FirFunctionType {
+    override var receiverTypeRef: FirTypeRef?,
+    override var returnTypeRef: FirTypeRef
+) : FirAbstractAnnotatedTypeRef(session, psi, isNullable), FirFunctionTypeRef {
     override val valueParameters = mutableListOf<FirValueParameter>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        receiverType = receiverType?.transformSingle(transformer, data)
-        returnType = returnType.transformSingle(transformer, data)
+        receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
+        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         valueParameters.transformInplace(transformer, data)
 
-        return super<FirAbstractAnnotatedType>.transformChildren(transformer, data)
+        return super<FirAbstractAnnotatedTypeRef>.transformChildren(transformer, data)
     }
 }

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

@@ -9,32 +9,32 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.types.FirImplicitType
+import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.name.Name
 
-sealed class FirImplicitBuiltinType(
+sealed class FirImplicitBuiltinTypeRef(
     override val session: FirSession,
     override val psi: PsiElement?,
     val name: Name
-) : FirImplicitType {
+) : FirImplicitTypeRef {
     override val annotations: List<FirAnnotationCall>
         get() = emptyList()
 
     constructor(session: FirSession, psi: PsiElement?, name: FqNameUnsafe) : this(session, psi, name.shortName())
 }
 
-class FirImplicitUnitType(
+class FirImplicitUnitTypeRef(
     session: FirSession,
     psi: PsiElement?
-) : FirImplicitBuiltinType(session, psi, KotlinBuiltIns.FQ_NAMES.unit)
+) : FirImplicitBuiltinTypeRef(session, psi, KotlinBuiltIns.FQ_NAMES.unit)
 
-class FirImplicitAnyType(
+class FirImplicitAnyTypeRef(
     session: FirSession,
     psi: PsiElement?
-) : FirImplicitBuiltinType(session, psi, KotlinBuiltIns.FQ_NAMES.any)
+) : FirImplicitBuiltinTypeRef(session, psi, KotlinBuiltIns.FQ_NAMES.any)
 
-class FirImplicitEnumType(
+class FirImplicitEnumTypeRef(
     session: FirSession,
     psi: PsiElement?
-) : FirImplicitBuiltinType(session, psi, KotlinBuiltIns.FQ_NAMES._enum)
+) : FirImplicitBuiltinTypeRef(session, psi, KotlinBuiltIns.FQ_NAMES._enum)

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

@@ -8,12 +8,12 @@ package org.jetbrains.kotlin.fir.types.impl
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.types.FirImplicitType
+import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 
-class FirImplicitTypeImpl(
+class FirImplicitTypeRefImpl(
     override val session: FirSession,
     override val psi: PsiElement?
-) : FirImplicitType {
+) : FirImplicitTypeRef {
     override val annotations: List<FirAnnotationCall>
         get() = emptyList()
 }

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

@@ -13,24 +13,24 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.fir.types.FirResolvedFunctionType
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirResolvedFunctionTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-class FirResolvedFunctionTypeImpl(
+class FirResolvedFunctionTypeRefImpl(
     override val psi: PsiElement?,
     override val session: FirSession,
     override val isMarkedNullable: Boolean,
     override val annotations: MutableList<FirAnnotationCall>,
-    override var receiverType: FirType?,
+    override var receiverTypeRef: FirTypeRef?,
     override val valueParameters: MutableList<FirValueParameter>,
-    override var returnType: FirType,
+    override var returnTypeRef: FirTypeRef,
     override val type: ConeKotlinType
-) : FirResolvedFunctionType {
+) : FirResolvedFunctionTypeRef {
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        receiverType = receiverType?.transformSingle(transformer, data)
-        returnType = returnType.transformSingle(transformer, data)
+        receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
+        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         valueParameters.transformInplace(transformer, data)
 
         return this

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

@@ -9,12 +9,12 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.fir.types.FirResolvedType
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 
-class FirResolvedTypeImpl(
+class FirResolvedTypeRefImpl(
     override val session: FirSession,
     override val psi: PsiElement?,
     override val type: ConeKotlinType,
     override val isMarkedNullable: Boolean,
     override val annotations: List<FirAnnotationCall>
-) : FirResolvedType
+) : FirResolvedTypeRef

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

@@ -9,7 +9,7 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.types.Variance
@@ -18,10 +18,10 @@ class FirTypeProjectionWithVarianceImpl(
     override val session: FirSession,
     override val psi: PsiElement?,
     override val variance: Variance,
-    override var type: FirType
+    override var typeRef: FirTypeRef
 ) : FirTypeProjectionWithVariance {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        type = type.transformSingle(transformer, data)
+        typeRef = typeRef.transformSingle(transformer, data)
 
         return this
     }

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

@@ -11,14 +11,14 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.types.FirQualifierPart
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
-import org.jetbrains.kotlin.fir.types.FirUserType
+import org.jetbrains.kotlin.fir.types.FirUserTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-class FirUserTypeImpl(
+class FirUserTypeRefImpl(
     session: FirSession,
     psi: PsiElement?,
     isNullable: Boolean
-) : FirAbstractAnnotatedType(session, psi, isNullable), FirUserType {
+) : FirAbstractAnnotatedTypeRef(session, psi, isNullable), FirUserTypeRef {
     override val qualifier = mutableListOf<FirQualifierPart>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
@@ -26,6 +26,6 @@ class FirUserTypeImpl(
             (part.typeArguments as MutableList<FirTypeProjection>).transformInplace(transformer, data)
         }
 
-        return super<FirAbstractAnnotatedType>.transformChildren(transformer, data)
+        return super<FirAbstractAnnotatedTypeRef>.transformChildren(transformer, data)
     }
 }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt

@@ -300,46 +300,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformTargetElement(labeledElement, data)
     }
 
-    open fun transformType(type: FirType, data: D): CompositeTransformResult<FirType> {
-        return transformElement(type, data)
-    }
-
-    open fun transformDelegatedType(delegatedType: FirDelegatedType, data: D): CompositeTransformResult<FirType> {
-        return transformType(delegatedType, data)
-    }
-
-    open fun transformErrorType(errorType: FirErrorType, data: D): CompositeTransformResult<FirType> {
-        return transformType(errorType, data)
-    }
-
-    open fun transformImplicitType(implicitType: FirImplicitType, data: D): CompositeTransformResult<FirType> {
-        return transformType(implicitType, data)
-    }
-
-    open fun transformTypeWithNullability(typeWithNullability: FirTypeWithNullability, data: D): CompositeTransformResult<FirType> {
-        return transformType(typeWithNullability, data)
-    }
-
-    open fun transformDynamicType(dynamicType: FirDynamicType, data: D): CompositeTransformResult<FirType> {
-        return transformTypeWithNullability(dynamicType, data)
-    }
-
-    open fun transformFunctionType(functionType: FirFunctionType, data: D): CompositeTransformResult<FirType> {
-        return transformTypeWithNullability(functionType, data)
-    }
-
-    open fun transformResolvedType(resolvedType: FirResolvedType, data: D): CompositeTransformResult<FirType> {
-        return transformTypeWithNullability(resolvedType, data)
-    }
-
-    open fun transformResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: D): CompositeTransformResult<FirType> {
-        return transformResolvedType(resolvedFunctionType, data)
-    }
-
-    open fun transformUserType(userType: FirUserType, data: D): CompositeTransformResult<FirType> {
-        return transformTypeWithNullability(userType, data)
-    }
-
     open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult<FirTypeProjection> {
         return transformElement(typeProjection, data)
     }
@@ -352,6 +312,46 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformTypeProjection(typeProjectionWithVariance, data)
     }
 
+    open fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformElement(typeRef, data)
+    }
+
+    open fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(delegatedTypeRef, data)
+    }
+
+    open fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(errorTypeRef, data)
+    }
+
+    open fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(implicitTypeRef, data)
+    }
+
+    open fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(typeRefWithNullability, data)
+    }
+
+    open fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRefWithNullability(dynamicTypeRef, data)
+    }
+
+    open fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRefWithNullability(functionTypeRef, data)
+    }
+
+    open fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRefWithNullability(resolvedTypeRef, data)
+    }
+
+    open fun transformResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformResolvedTypeRef(resolvedFunctionTypeRef, data)
+    }
+
+    open fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRefWithNullability(userTypeRef, data)
+    }
+
     open fun <E : FirElement> transformWhenBranch(whenBranch: E, data: D): CompositeTransformResult<E> {
         return transformElement(whenBranch, data)
     }
@@ -448,16 +448,16 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformDelegatedConstructorCall(delegatedConstructorCall, data)
     }
 
-    final override fun visitDelegatedType(delegatedType: FirDelegatedType, data: D): CompositeTransformResult<FirElement> {
-        return transformDelegatedType(delegatedType, data)
+    final override fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): CompositeTransformResult<FirElement> {
+        return transformDelegatedTypeRef(delegatedTypeRef, data)
     }
 
     final override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): CompositeTransformResult<FirElement> {
         return transformDoWhileLoop(doWhileLoop, data)
     }
 
-    final override fun visitDynamicType(dynamicType: FirDynamicType, data: D): CompositeTransformResult<FirElement> {
-        return transformDynamicType(dynamicType, data)
+    final override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult<FirElement> {
+        return transformDynamicTypeRef(dynamicTypeRef, data)
     }
 
     final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult<FirElement> {
@@ -472,8 +472,8 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformErrorExpression(errorExpression, data)
     }
 
-    final override fun visitErrorType(errorType: FirErrorType, data: D): CompositeTransformResult<FirElement> {
-        return transformErrorType(errorType, data)
+    final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirElement> {
+        return transformErrorTypeRef(errorTypeRef, data)
     }
 
     final override fun visitExpression(expression: FirExpression, data: D): CompositeTransformResult<FirElement> {
@@ -492,16 +492,16 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformFunctionCall(functionCall, data)
     }
 
-    final override fun visitFunctionType(functionType: FirFunctionType, data: D): CompositeTransformResult<FirElement> {
-        return transformFunctionType(functionType, data)
+    final override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult<FirElement> {
+        return transformFunctionTypeRef(functionTypeRef, data)
     }
 
     final override fun visitGetClassCall(getClassCall: FirGetClassCall, data: D): CompositeTransformResult<FirElement> {
         return transformGetClassCall(getClassCall, data)
     }
 
-    final override fun visitImplicitType(implicitType: FirImplicitType, data: D): CompositeTransformResult<FirElement> {
-        return transformImplicitType(implicitType, data)
+    final override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult<FirElement> {
+        return transformImplicitTypeRef(implicitTypeRef, data)
     }
 
     final override fun visitImport(import: FirImport, data: D): CompositeTransformResult<FirElement> {
@@ -592,16 +592,16 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformResolvedDeclarationStatus(resolvedDeclarationStatus, data)
     }
 
-    final override fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: D): CompositeTransformResult<FirElement> {
-        return transformResolvedFunctionType(resolvedFunctionType, data)
+    final override fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): CompositeTransformResult<FirElement> {
+        return transformResolvedFunctionTypeRef(resolvedFunctionTypeRef, data)
     }
 
     final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: D): CompositeTransformResult<FirElement> {
         return transformResolvedImport(resolvedImport, data)
     }
 
-    final override fun visitResolvedType(resolvedType: FirResolvedType, data: D): CompositeTransformResult<FirElement> {
-        return transformResolvedType(resolvedType, data)
+    final override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult<FirElement> {
+        return transformResolvedTypeRef(resolvedTypeRef, data)
     }
 
     final override fun visitReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult<FirElement> {
@@ -636,10 +636,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformTryExpression(tryExpression, data)
     }
 
-    final override fun visitType(type: FirType, data: D): CompositeTransformResult<FirElement> {
-        return transformType(type, data)
-    }
-
     final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirElement> {
         return transformTypeAlias(typeAlias, data)
     }
@@ -660,16 +656,20 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformTypeProjectionWithVariance(typeProjectionWithVariance, data)
     }
 
-    final override fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability, data: D): CompositeTransformResult<FirElement> {
-        return transformTypeWithNullability(typeWithNullability, data)
+    final override fun visitTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult<FirElement> {
+        return transformTypeRef(typeRef, data)
+    }
+
+    final override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult<FirElement> {
+        return transformTypeRefWithNullability(typeRefWithNullability, data)
     }
 
     final override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): CompositeTransformResult<FirElement> {
         return transformTypedDeclaration(typedDeclaration, data)
     }
 
-    final override fun visitUserType(userType: FirUserType, data: D): CompositeTransformResult<FirElement> {
-        return transformUserType(userType, data)
+    final override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult<FirElement> {
+        return transformUserTypeRef(userTypeRef, data)
     }
 
     final override fun visitValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult<FirElement> {

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt

@@ -300,46 +300,6 @@ abstract class FirVisitor<out R, in D> {
         return visitTargetElement(labeledElement, data)
     }
 
-    open fun visitType(type: FirType, data: D): R {
-        return visitElement(type, data)
-    }
-
-    open fun visitDelegatedType(delegatedType: FirDelegatedType, data: D): R {
-        return visitType(delegatedType, data)
-    }
-
-    open fun visitErrorType(errorType: FirErrorType, data: D): R {
-        return visitType(errorType, data)
-    }
-
-    open fun visitImplicitType(implicitType: FirImplicitType, data: D): R {
-        return visitType(implicitType, data)
-    }
-
-    open fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability, data: D): R {
-        return visitType(typeWithNullability, data)
-    }
-
-    open fun visitDynamicType(dynamicType: FirDynamicType, data: D): R {
-        return visitTypeWithNullability(dynamicType, data)
-    }
-
-    open fun visitFunctionType(functionType: FirFunctionType, data: D): R {
-        return visitTypeWithNullability(functionType, data)
-    }
-
-    open fun visitResolvedType(resolvedType: FirResolvedType, data: D): R {
-        return visitTypeWithNullability(resolvedType, data)
-    }
-
-    open fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: D): R {
-        return visitResolvedType(resolvedFunctionType, data)
-    }
-
-    open fun visitUserType(userType: FirUserType, data: D): R {
-        return visitTypeWithNullability(userType, data)
-    }
-
     open fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): R {
         return visitElement(typeProjection, data)
     }
@@ -352,6 +312,46 @@ abstract class FirVisitor<out R, in D> {
         return visitTypeProjection(typeProjectionWithVariance, data)
     }
 
+    open fun visitTypeRef(typeRef: FirTypeRef, data: D): R {
+        return visitElement(typeRef, data)
+    }
+
+    open fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): R {
+        return visitTypeRef(delegatedTypeRef, data)
+    }
+
+    open fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): R {
+        return visitTypeRef(errorTypeRef, data)
+    }
+
+    open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): R {
+        return visitTypeRef(implicitTypeRef, data)
+    }
+
+    open fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): R {
+        return visitTypeRef(typeRefWithNullability, data)
+    }
+
+    open fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): R {
+        return visitTypeRefWithNullability(dynamicTypeRef, data)
+    }
+
+    open fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): R {
+        return visitTypeRefWithNullability(functionTypeRef, data)
+    }
+
+    open fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): R {
+        return visitTypeRefWithNullability(resolvedTypeRef, data)
+    }
+
+    open fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): R {
+        return visitResolvedTypeRef(resolvedFunctionTypeRef, data)
+    }
+
+    open fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): R {
+        return visitTypeRefWithNullability(userTypeRef, data)
+    }
+
     open fun visitWhenBranch(whenBranch: FirWhenBranch, data: D): R {
         return visitElement(whenBranch, data)
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt

@@ -300,46 +300,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitTargetElement(labeledElement, null)
     }
 
-    open fun visitType(type: FirType) {
-        visitElement(type, null)
-    }
-
-    open fun visitDelegatedType(delegatedType: FirDelegatedType) {
-        visitType(delegatedType, null)
-    }
-
-    open fun visitErrorType(errorType: FirErrorType) {
-        visitType(errorType, null)
-    }
-
-    open fun visitImplicitType(implicitType: FirImplicitType) {
-        visitType(implicitType, null)
-    }
-
-    open fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability) {
-        visitType(typeWithNullability, null)
-    }
-
-    open fun visitDynamicType(dynamicType: FirDynamicType) {
-        visitTypeWithNullability(dynamicType, null)
-    }
-
-    open fun visitFunctionType(functionType: FirFunctionType) {
-        visitTypeWithNullability(functionType, null)
-    }
-
-    open fun visitResolvedType(resolvedType: FirResolvedType) {
-        visitTypeWithNullability(resolvedType, null)
-    }
-
-    open fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType) {
-        visitResolvedType(resolvedFunctionType, null)
-    }
-
-    open fun visitUserType(userType: FirUserType) {
-        visitTypeWithNullability(userType, null)
-    }
-
     open fun visitTypeProjection(typeProjection: FirTypeProjection) {
         visitElement(typeProjection, null)
     }
@@ -352,6 +312,46 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitTypeProjection(typeProjectionWithVariance, null)
     }
 
+    open fun visitTypeRef(typeRef: FirTypeRef) {
+        visitElement(typeRef, null)
+    }
+
+    open fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef) {
+        visitTypeRef(delegatedTypeRef, null)
+    }
+
+    open fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {
+        visitTypeRef(errorTypeRef, null)
+    }
+
+    open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) {
+        visitTypeRef(implicitTypeRef, null)
+    }
+
+    open fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) {
+        visitTypeRef(typeRefWithNullability, null)
+    }
+
+    open fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) {
+        visitTypeRefWithNullability(dynamicTypeRef, null)
+    }
+
+    open fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) {
+        visitTypeRefWithNullability(functionTypeRef, null)
+    }
+
+    open fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
+        visitTypeRefWithNullability(resolvedTypeRef, null)
+    }
+
+    open fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef) {
+        visitResolvedTypeRef(resolvedFunctionTypeRef, null)
+    }
+
+    open fun visitUserTypeRef(userTypeRef: FirUserTypeRef) {
+        visitTypeRefWithNullability(userTypeRef, null)
+    }
+
     open fun visitWhenBranch(whenBranch: FirWhenBranch) {
         visitElement(whenBranch, null)
     }
@@ -448,16 +448,16 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitDelegatedConstructorCall(delegatedConstructorCall)
     }
 
-    final override fun visitDelegatedType(delegatedType: FirDelegatedType, data: Nothing?) {
-        visitDelegatedType(delegatedType)
+    final override fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: Nothing?) {
+        visitDelegatedTypeRef(delegatedTypeRef)
     }
 
     final override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: Nothing?) {
         visitDoWhileLoop(doWhileLoop)
     }
 
-    final override fun visitDynamicType(dynamicType: FirDynamicType, data: Nothing?) {
-        visitDynamicType(dynamicType)
+    final override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: Nothing?) {
+        visitDynamicTypeRef(dynamicTypeRef)
     }
 
     final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Nothing?) {
@@ -472,8 +472,8 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitErrorExpression(errorExpression)
     }
 
-    final override fun visitErrorType(errorType: FirErrorType, data: Nothing?) {
-        visitErrorType(errorType)
+    final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?) {
+        visitErrorTypeRef(errorTypeRef)
     }
 
     final override fun visitExpression(expression: FirExpression, data: Nothing?) {
@@ -492,16 +492,16 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitFunctionCall(functionCall)
     }
 
-    final override fun visitFunctionType(functionType: FirFunctionType, data: Nothing?) {
-        visitFunctionType(functionType)
+    final override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: Nothing?) {
+        visitFunctionTypeRef(functionTypeRef)
     }
 
     final override fun visitGetClassCall(getClassCall: FirGetClassCall, data: Nothing?) {
         visitGetClassCall(getClassCall)
     }
 
-    final override fun visitImplicitType(implicitType: FirImplicitType, data: Nothing?) {
-        visitImplicitType(implicitType)
+    final override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?) {
+        visitImplicitTypeRef(implicitTypeRef)
     }
 
     final override fun visitImport(import: FirImport, data: Nothing?) {
@@ -592,16 +592,16 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitResolvedDeclarationStatus(resolvedDeclarationStatus)
     }
 
-    final override fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: Nothing?) {
-        visitResolvedFunctionType(resolvedFunctionType)
+    final override fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: Nothing?) {
+        visitResolvedFunctionTypeRef(resolvedFunctionTypeRef)
     }
 
     final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: Nothing?) {
         visitResolvedImport(resolvedImport)
     }
 
-    final override fun visitResolvedType(resolvedType: FirResolvedType, data: Nothing?) {
-        visitResolvedType(resolvedType)
+    final override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?) {
+        visitResolvedTypeRef(resolvedTypeRef)
     }
 
     final override fun visitReturnExpression(returnExpression: FirReturnExpression, data: Nothing?) {
@@ -636,10 +636,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitTryExpression(tryExpression)
     }
 
-    final override fun visitType(type: FirType, data: Nothing?) {
-        visitType(type)
-    }
-
     final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Nothing?) {
         visitTypeAlias(typeAlias)
     }
@@ -660,16 +656,20 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitTypeProjectionWithVariance(typeProjectionWithVariance)
     }
 
-    final override fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability, data: Nothing?) {
-        visitTypeWithNullability(typeWithNullability)
+    final override fun visitTypeRef(typeRef: FirTypeRef, data: Nothing?) {
+        visitTypeRef(typeRef)
+    }
+
+    final override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: Nothing?) {
+        visitTypeRefWithNullability(typeRefWithNullability)
     }
 
     final override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: Nothing?) {
         visitTypedDeclaration(typedDeclaration)
     }
 
-    final override fun visitUserType(userType: FirUserType, data: Nothing?) {
-        visitUserType(userType)
+    final override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: Nothing?) {
+        visitUserTypeRef(userTypeRef)
     }
 
     final override fun visitValueParameter(valueParameter: FirValueParameter, data: Nothing?) {

compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt

@@ -8,8 +8,8 @@ import com.intellij.openapi.fileEditor.FileDocumentManager
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType
-import org.jetbrains.kotlin.fir.types.FirResolvedType
-import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.psi.KtFile
@@ -65,18 +65,18 @@ fun doFirResolveTestBench(firFiles: List<FirFile>, transformers: List<FirTransfo
                     element.acceptChildren(this)
                 }
 
-                override fun visitType(type: FirType) {
+                override fun visitTypeRef(typeRef: FirTypeRef) {
                     unresolvedTypes++
                 }
 
-                override fun visitResolvedType(resolvedType: FirResolvedType) {
+                override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
                     resolvedTypes++
-                    val type = resolvedType.type
+                    val type = resolvedTypeRef.type
                     if (type is ConeKotlinErrorType || type is ConeClassErrorType) {
-                        if (resolvedType.psi == null) {
+                        if (resolvedTypeRef.psi == null) {
                             implicitTypes++
                         } else {
-                            val psi = resolvedType.psi!!
+                            val psi = resolvedTypeRef.psi!!
                             val problem = "$type with psi `${psi.text}`"
                             val document = try {
                                 fileDocumentManager.getDocument(psi.containingFile.virtualFile)