From c295f2dc25c4f0d5a2b10997a4cc536d538608c5 Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Thu, 23 Jan 2020 11:35:56 +0300 Subject: [PATCH] FIR: Reimplement implicit types calculator Make it works through a single component tracking computation status instead of storing it in the nodes --- .../resolve/transformers/ResolvePhaseUtils.kt | 3 +- .../FirAbstractBodyResolveTransformer.kt | 3 +- .../body/resolve/FirBodyResolveTransformer.kt | 9 +- .../FirDeclarationsResolveTransformer.kt | 39 ++- .../body/resolve/FirImplicitBodyResolve.kt | 248 ++++++++++++++++++ .../scopes/impl/FirClassSubstitutionScope.kt | 19 +- .../kotlin/fir/resolve/ScopeSession.kt | 2 + .../objectExpression.fir.kt | 12 +- .../recursiveGetter.fir.kt | 4 +- .../tests/regressions/Jet81.fir.kt | 6 +- .../diagnostics/tests/regressions/Jet81.kt | 2 +- 11 files changed, 311 insertions(+), 36 deletions(-) create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt index e666d1f2cc8..bdf9efb171c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase.* import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformerAdapter import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitTypeBodyResolveTransformerAdapter +import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitTypeBodyResolveTransformerAdapter2 import org.jetbrains.kotlin.fir.visitors.FirTransformer // TODO: add FirSession parameter @@ -20,7 +21,7 @@ fun FirResolvePhase.createTransformerByPhase(): FirTransformer { SEALED_CLASS_INHERITORS -> FirSealedClassInheritorsTransformer() TYPES -> FirTypeResolveTransformer() STATUS -> FirStatusResolveTransformer() - IMPLICIT_TYPES_BODY_RESOLVE -> FirImplicitTypeBodyResolveTransformerAdapter() + IMPLICIT_TYPES_BODY_RESOLVE -> FirImplicitTypeBodyResolveTransformerAdapter2() BODY_RESOLVE -> FirBodyResolveTransformerAdapter() } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt index 0189c5c7e5e..108d29b52f5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt @@ -69,7 +69,6 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb protected inline val symbolProvider: FirSymbolProvider get() = components.symbolProvider - protected inline val returnTypeCalculator: ReturnTypeCalculator get() = components.returnTypeCalculator protected inline val implicitReceiverStack: ImplicitReceiverStack get() = components.implicitReceiverStack protected inline val inferenceComponents: InferenceComponents get() = components.inferenceComponents protected inline val resolutionStageRunner: ResolutionStageRunner get() = components.resolutionStageRunner @@ -105,7 +104,7 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb override val symbolProvider: FirSymbolProvider = session.firSymbolProvider - override val returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorWithJump(session, scopeSession) + override val returnTypeCalculator: ReturnTypeCalculator = transformer.returnTypeCalculator override val implicitReceiverStack: ImplicitReceiverStack = ImplicitReceiverStackImpl() override val inferenceComponents: InferenceComponents = inferenceComponents(session, returnTypeCalculator, scopeSession) override val resolutionStageRunner: ResolutionStageRunner = ResolutionStageRunner(inferenceComponents) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt index 3a9631bf06c..5ed4ae9f416 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt @@ -13,6 +13,8 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator +import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorWithJump import org.jetbrains.kotlin.fir.scopes.addImportingScopes import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef @@ -26,7 +28,8 @@ open class FirBodyResolveTransformer( session: FirSession, phase: FirResolvePhase, override var implicitTypeOnly: Boolean, - scopeSession: ScopeSession + scopeSession: ScopeSession, + val returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorWithJump(session, scopeSession) ) : FirAbstractBodyResolveTransformer(phase) { private var packageFqName = FqName.ROOT @@ -173,7 +176,7 @@ open class FirBodyResolveTransformer( return declarationsTransformer.transformDeclarationStatus(declarationStatus, data) } - override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { return declarationsTransformer.transformProperty(property, data) } @@ -185,7 +188,7 @@ open class FirBodyResolveTransformer( return declarationsTransformer.transformAnonymousObject(anonymousObject, data) } - override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: ResolutionMode): CompositeTransformResult { + override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: ResolutionMode): CompositeTransformResult { return declarationsTransformer.transformSimpleFunction(simpleFunction, data) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index d404166be8d..edd51c2d23c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -74,7 +74,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) } } - override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { return withScopeCleanup(topLevelScopes) { prepareTypeParameterOwnerForBodyResolve(property) if (property.isLocal) { @@ -120,7 +120,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) } } - private fun transformLocalVariable(variable: FirProperty): CompositeTransformResult { + private fun transformLocalVariable(variable: FirProperty): CompositeTransformResult { assert(variable.isLocal) val resolutionMode = withExpectedType(variable.returnTypeRef) variable.transformInitializer(transformer, resolutionMode) @@ -297,7 +297,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) } } - override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: ResolutionMode): CompositeTransformResult { + override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: ResolutionMode): CompositeTransformResult { return withScopeCleanup(topLevelScopes) { prepareTypeParameterOwnerForBodyResolve(simpleFunction) val containingDeclaration = components.containerIfAny @@ -327,21 +327,32 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) } } - private fun transformFunctionWithGivenSignature( - function: FirFunction<*>, + private fun > transformFunctionWithGivenSignature( + function: F, returnTypeRef: FirTypeRef - ): CompositeTransformResult { + ): CompositeTransformResult { if (function is FirSimpleFunction) { localScopes.lastOrNull()?.storeDeclaration(function) } - val result = transformFunction(function, withExpectedType(returnTypeRef)).single as FirFunction<*> + + @Suppress("UNCHECKED_CAST") + val result = transformFunction(function, withExpectedType(returnTypeRef)).single as F + val body = result.body - return if (result.returnTypeRef is FirImplicitTypeRef && body != null) { - result.transformReturnTypeRef(transformer, withExpectedType(body.resultType)) - result - } else { - result - }.compose() + if (result.returnTypeRef is FirImplicitTypeRef) { + if (body != null) { + result.transformReturnTypeRef(transformer, withExpectedType(body.resultType)) + } else { + result.transformReturnTypeRef( + transformer, + withExpectedType( + FirErrorTypeRefImpl(null, FirSimpleDiagnostic("empty body", DiagnosticKind.Other)) + ) + ) + } + } + + return result.compose() } override fun > transformFunction(function: FirFunction, data: ResolutionMode): CompositeTransformResult { @@ -466,7 +477,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) val writer = FirCallCompletionResultsWriterTransformer( session, ConeSubstitutor.Empty, - returnTypeCalculator, + components.returnTypeCalculator, inferenceComponents.approximator, integerOperatorsTypeUpdater, integerLiteralTypeApproximator diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt new file mode 100644 index 00000000000..00eaf284ec1 --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt @@ -0,0 +1,248 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +@file:Suppress("DuplicatedCode") + +package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve + +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind +import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.render +import org.jetbrains.kotlin.fir.resolve.ResolutionMode +import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.resolve.firProvider +import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator +import org.jetbrains.kotlin.fir.resolve.transformers.TransformImplicitType +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef +import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef +import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl +import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult +import org.jetbrains.kotlin.fir.visitors.FirTransformer +import org.jetbrains.kotlin.fir.visitors.compose + +@Deprecated("It is temp", level = DeprecationLevel.WARNING, replaceWith = ReplaceWith("TODO(\"что-то нормальное\")")) +class FirImplicitTypeBodyResolveTransformerAdapter2 : FirTransformer() { + private val scopeSession = ScopeSession() + private val implicitBodyResolveComputationSession = ImplicitBodyResolveComputationSession() + + override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { + return element.compose() + } + + override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + val session = file.session + scopeSession.returnTypeCalculator = MyReturnTypeCalculatorWithJump(session, scopeSession, implicitBodyResolveComputationSession) + val transformer = MyFirBodyResolveTransformer( + session, + scopeSession, + implicitBodyResolveComputationSession + ) + return file.transform(transformer, ResolutionMode.ContextIndependent) + } +} + +private open class MyFirBodyResolveTransformer( + session: FirSession, + scopeSession: ScopeSession, + private val implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession +) : FirBodyResolveTransformer( + session, + phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, + implicitTypeOnly = true, + scopeSession = scopeSession, + returnTypeCalculator = MyReturnTypeCalculatorWithJump(session, scopeSession, implicitBodyResolveComputationSession) +) { + override fun transformSimpleFunction( + simpleFunction: FirSimpleFunction, + data: ResolutionMode + ): CompositeTransformResult { + return computeCachedTransformationResult(simpleFunction) { + super.transformSimpleFunction(simpleFunction, data) + } + } + + override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { + return computeCachedTransformationResult(property) { + super.transformProperty(property, data) + } + } + + private fun > computeCachedTransformationResult( + member: D, + transform: () -> CompositeTransformResult + ): CompositeTransformResult { + if (!implicitTypeOnly && member.returnTypeRef is FirResolvedTypeRef) { + return transform() + } + + if (member.returnTypeRef is FirResolvedTypeRef) return member.compose() + val symbol = member.symbol + val status = implicitBodyResolveComputationSession.getStatus(symbol) + if (status is ImplicitBodyResolveComputationStatus.Computed) { + @Suppress("UNCHECKED_CAST") + return status.transformedDeclaration.compose() as CompositeTransformResult + } + + // If somebody has started resolution recursively (from ReturnTypeCalculator), one has to track it's not being computed already + require(status is ImplicitBodyResolveComputationStatus.NotComputed) { + "Unexpected status in transformCallableMember ($status) for ${member.render()}" + } + + implicitBodyResolveComputationSession.startComputing(symbol) + val result = transform() + implicitBodyResolveComputationSession.storeResult(symbol, result.single) + + return result + } +} + +private class MyReturnTypeCalculatorWithJump( + private val session: FirSession, + private val scopeSession: ScopeSession, + private val implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession +) : ReturnTypeCalculator { + + override fun tryCalculateReturnType(declaration: FirTypedDeclaration): FirResolvedTypeRef { + if (declaration is FirValueParameter && declaration.returnTypeRef is FirImplicitTypeRef) { + // TODO? + declaration.transformReturnTypeRef( + TransformImplicitType, + FirErrorTypeRefImpl( + null, + FirSimpleDiagnostic("Unsupported: implicit VP type") + ) + ) + } + + val returnTypeRef = declaration.returnTypeRef + if (returnTypeRef is FirResolvedTypeRef) return returnTypeRef + + require(declaration is FirCallableMemberDeclaration<*>) { "${declaration::class}: ${declaration.render()}" } + + return when (val status = implicitBodyResolveComputationSession.getStatus(declaration.symbol)) { + is ImplicitBodyResolveComputationStatus.Computed -> status.resolvedTypeRef + is ImplicitBodyResolveComputationStatus.Computing -> + FirErrorTypeRefImpl(null, FirSimpleDiagnostic("cycle", DiagnosticKind.RecursionInImplicitTypes)) + else -> computeReturnTypeRef(declaration) + } + } + + private fun computeReturnTypeRef(declaration: FirCallableMemberDeclaration<*>): FirResolvedTypeRef { + val symbol = declaration.symbol + val id = symbol.callableId + + val provider = session.firProvider + + val file = provider.getFirCallableContainerFile(symbol) + + val outerClasses = generateSequence(id.classId) { classId -> + classId.outerClassId + }.mapTo(mutableListOf()) { provider.getFirClassifierByFqName(it) } + + if (file == null || outerClasses.any { it == null }) { + return FirErrorTypeRefImpl( + null, + FirSimpleDiagnostic( + "Cannot calculate return type (local class/object?)", + DiagnosticKind.InferenceError + ) + ) + } + val designation = (listOf(file) + outerClasses.filterNotNull().asReversed() + listOf(declaration)) + val transformer = MyFirDesignatedBodyResolveTransformer( + designation.iterator(), + file.session, + scopeSession, + implicitBodyResolveComputationSession + ) + + file.transform(transformer, ResolutionMode.ContextDependent) + + val transformedDeclaration = transformer.lastResult as? FirCallableMemberDeclaration<*> + ?: error("Unexpected lastResult: ${transformer.lastResult?.render()}") + + val newReturnTypeRef = transformedDeclaration.returnTypeRef + require(newReturnTypeRef is FirResolvedTypeRef) { transformedDeclaration.render() } + return newReturnTypeRef + } +} + +private class MyFirDesignatedBodyResolveTransformer( + private val designation: Iterator, + session: FirSession, + scopeSession: ScopeSession, + implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession +) : MyFirBodyResolveTransformer( + session, + scopeSession, + implicitBodyResolveComputationSession +) { + + var lastResult: FirElement? = null + + override fun transformElement(element: E, data: ResolutionMode): CompositeTransformResult { + if (designation.hasNext()) { + val result = designation.next().transform(this, data).single + if (!designation.hasNext()) { + lastResult = result + } + return result.compose() + } + return super.transformElement(element, data) + } + + override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult { + return components.withContainer(declaration) { + declaration.replaceResolvePhase(transformerPhase) + transformElement(declaration, data) + } + } +} + +private class ImplicitBodyResolveComputationSession { + private val implicitBodyResolveStatusMap = hashMapOf, ImplicitBodyResolveComputationStatus>() + + fun getStatus(symbol: FirCallableSymbol<*>): ImplicitBodyResolveComputationStatus { + return implicitBodyResolveStatusMap[symbol] ?: ImplicitBodyResolveComputationStatus.NotComputed + } + + fun startComputing(symbol: FirCallableSymbol<*>) { + require(implicitBodyResolveStatusMap[symbol] == null) { + "Unexpected static in startComputing for $symbol: ${implicitBodyResolveStatusMap[symbol]}" + } + + implicitBodyResolveStatusMap[symbol] = ImplicitBodyResolveComputationStatus.Computing + } + + fun storeResult( + symbol: FirCallableSymbol<*>, + transformedDeclaration: FirCallableMemberDeclaration<*> + ) { + require(implicitBodyResolveStatusMap[symbol] == ImplicitBodyResolveComputationStatus.Computing) { + "Unexpected static in storeResult for $symbol: ${implicitBodyResolveStatusMap[symbol]}" + } + + val returnTypeRef = transformedDeclaration.returnTypeRef + require(returnTypeRef is FirResolvedTypeRef) { + "Not FirResolvedTypeRef (${transformedDeclaration.receiverTypeRef?.render()}) in storeResult for: ${symbol.fir.render()}" + } + + implicitBodyResolveStatusMap[symbol] = ImplicitBodyResolveComputationStatus.Computed(returnTypeRef, transformedDeclaration) + } +} + +private sealed class ImplicitBodyResolveComputationStatus { + object NotComputed : ImplicitBodyResolveComputationStatus() + object Computing : ImplicitBodyResolveComputationStatus() + + class Computed( + val resolvedTypeRef: FirResolvedTypeRef, + val transformedDeclaration: FirCallableMemberDeclaration<*> + ) : ImplicitBodyResolveComputationStatus() +} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt index 600a62b4818..88996193354 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.substitution.ChainedSubstitutor import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap +import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorWithJump import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.symbols.impl.* @@ -80,7 +81,8 @@ class FirClassSubstitutionScope( useSiteMemberScope.processClassifiersByName(name, processor) } - private val typeCalculator by lazy { ReturnTypeCalculatorWithJump(session, scopeSession) } + private val typeCalculator = + (scopeSession.returnTypeCalculator as ReturnTypeCalculator?) ?: ReturnTypeCalculatorWithJump(session, scopeSession) private fun ConeKotlinType.substitute(): ConeKotlinType? { return substitutor.substituteOrNull(this) @@ -221,7 +223,7 @@ class FirClassSubstitutionScope( FirSimpleFunctionImpl( source, session, - baseFunction.returnTypeRef.withReplacedConeType(newReturnType), + baseFunction.returnTypeRef.withReplacedReturnType(newReturnType), baseFunction.receiverTypeRef?.withReplacedConeType(newReceiverType), name, baseFunction.status, @@ -286,7 +288,7 @@ class FirClassSubstitutionScope( FirPropertyImpl( source, session, - baseProperty.returnTypeRef.withReplacedConeType(newReturnType), + baseProperty.returnTypeRef.withReplacedReturnType(newReturnType), baseProperty.receiverTypeRef?.withReplacedConeType(newReceiverType), name, null, @@ -337,6 +339,16 @@ class FirClassSubstitutionScope( } } +// Unlike other cases, return types may be implicit, i.e. unresolved +// But in that cases newType should also be `null` +fun FirTypeRef.withReplacedReturnType(newType: ConeKotlinType?): FirTypeRef { + require(this is FirResolvedTypeRef || newType == null) + if (newType == null) return this + + return FirResolvedTypeRefImpl(source, newType).apply { + annotations += this@withReplacedReturnType.annotations + } +} fun FirTypeRef.withReplacedConeType(newType: ConeKotlinType?): FirResolvedTypeRef { require(this is FirResolvedTypeRef) @@ -345,5 +357,4 @@ fun FirTypeRef.withReplacedConeType(newType: ConeKotlinType?): FirResolvedTypeRe return FirResolvedTypeRefImpl(source, newType).apply { annotations += this@withReplacedConeType.annotations } - } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/resolve/ScopeSession.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/resolve/ScopeSession.kt index 63d2c670bd7..491335a441e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/resolve/ScopeSession.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/resolve/ScopeSession.kt @@ -10,6 +10,8 @@ import org.jetbrains.kotlin.fir.scopes.FirScope class ScopeSession { private val scopes = hashMapOf, FirScope>>() + var returnTypeCalculator: Any? = null + @Deprecated(level = DeprecationLevel.ERROR, message = "Only for getOrBuild") fun scopes() = scopes diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt index 9be9503435e..eb78d1bccf5 100644 --- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt +++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt @@ -7,7 +7,7 @@ object Outer { get() = 0 override fun get(index: Int): Char { - checkSubtype(x) + checkSubtype(x) return ' ' } @@ -17,7 +17,7 @@ object Outer { } } set(q) { - checkSubtype(x) + checkSubtype(x) y = q x = q } @@ -27,10 +27,10 @@ object Outer { fun foo() { x = y - checkSubtype(x) - checkSubtype(y) + checkSubtype(x) + checkSubtype(y) - x.bar() - y.bar() + x.bar() + y.bar() } } diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt index 7550d94921b..672898f39a8 100644 --- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt +++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt @@ -10,8 +10,8 @@ class A { val a get() = b val b get() = a - val z1 get() = id(z1) - val z2 get() = l(z2) + val z1 get() = id(z1) + val z2 get() = l(z2) val u get() = field } diff --git a/compiler/testData/diagnostics/tests/regressions/Jet81.fir.kt b/compiler/testData/diagnostics/tests/regressions/Jet81.fir.kt index c1e59e0a376..d7fbd05f526 100644 --- a/compiler/testData/diagnostics/tests/regressions/Jet81.fir.kt +++ b/compiler/testData/diagnostics/tests/regressions/Jet81.fir.kt @@ -7,7 +7,7 @@ class Test { val a = y; } - val z = y.a; + val z = y.a; } @@ -24,6 +24,6 @@ class Test2 { val y = 1 } - val b = a.x + val b = a.x val c = a.y -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/regressions/Jet81.kt b/compiler/testData/diagnostics/tests/regressions/Jet81.kt index ec2e379b22b..6e2635c377d 100644 --- a/compiler/testData/diagnostics/tests/regressions/Jet81.kt +++ b/compiler/testData/diagnostics/tests/regressions/Jet81.kt @@ -26,4 +26,4 @@ class Test2 { val b = a.x val c = a.y -} \ No newline at end of file +}