FIR rename: FirType -> FirTypeRef and related

2019-02-11 16:13:04 +03:00
parent 1c76a612f9
commit 5afb0a6f4a
71 changed files with 599 additions and 601 deletions
@@ -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
 }
@@ -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)
                }
@@ -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("!")
        }
@@ -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))
        }
    }
 }
@@ -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
@@ -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
@@ -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|

        }

@@ -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|)
@@ -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|()
    }
@@ -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|)
@@ -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>#
        }