From 42345b9c49295e3253aefb0a1bd8866459408f1e Mon Sep 17 00:00:00 2001 From: Dmitry Savvinov Date: Thu, 25 Feb 2021 18:02:05 +0300 Subject: [PATCH] Minor: use more clear and specific naming for LazyClassContext.typeChecker (relevant for MPP with type refinement) --- .../kotlin/resolve/lazy/LazyClassContext.kt | 18 +++++++++++++++++- .../kotlin/resolve/lazy/ResolveSession.java | 2 +- .../lazy/descriptors/LazyClassDescriptor.java | 11 +++++------ .../lazy/descriptors/LazyClassMemberScope.kt | 2 +- .../expressions/LocalClassifierAnalyzer.kt | 2 +- .../scripting/resolve/LazyScriptDescriptor.kt | 4 ++-- 6 files changed, 27 insertions(+), 12 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt index 47107bdbe38..214e737ce39 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt @@ -45,8 +45,24 @@ interface LazyClassContext { val syntheticResolveExtension: SyntheticResolveExtension val delegationFilter: DelegationFilter val wrappedTypeFactory: WrappedTypeFactory - val kotlinTypeChecker: NewKotlinTypeChecker val samConversionResolver: SamConversionResolver val additionalClassPartsProvider: AdditionalClassPartsProvider val sealedClassInheritorsProvider: SealedClassInheritorsProvider + + /** + * Important notice! + * + * This is the type checker of *owner* module, i.e. the module which has declared the class. + * + * In MPP, we have different "views" on the one and the same class. I.e. if we have a common 'class Foo : Expect', + * and on JVM we have 'actual typealias Expect = CharSequence', then from "common view" Foo isn't assigneable to CharSequence, + * while from the "JVM view" it is. + * + * LazyClassContext is usually shared across all such views, so be careful - using this typechecker in "platform views" is not correct. + * Relevant entities usually have a separate instance of KotlinTypeChecker/KotlinTypeRefiner, see for example + * [org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassMemberScope]. + * + * See also KT-44898 for example of issues which might happen if the wrong typechecker is used in "platform view". + */ + val kotlinTypeCheckerOfOwnerModule: NewKotlinTypeChecker } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java index c597435ad03..872360e2215 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java @@ -504,7 +504,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { @NotNull @Override - public NewKotlinTypeChecker getKotlinTypeChecker() { + public NewKotlinTypeChecker getKotlinTypeCheckerOfOwnerModule() { return kotlinTypeChecker; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java index 55c7abd6abf..9d21cb787c1 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java @@ -327,16 +327,15 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes return ScopesHolderForClass.Companion.create( this, c.getStorageManager(), - c.getKotlinTypeChecker().getKotlinTypeRefiner(), - kotlinTypeRefiner -> { + c.getKotlinTypeCheckerOfOwnerModule().getKotlinTypeRefiner(), + kotlinTypeRefinerForDependentModule -> { LazyClassMemberScope scopeForDeclaredMembers = - !kotlinTypeRefiner.isRefinementNeededForModule(c.getModuleDescriptor()) + !kotlinTypeRefinerForDependentModule.isRefinementNeededForModule(c.getModuleDescriptor()) ? null - // TODO: or kotlinTypeRefiner.getModuleDescriptor() - : scopesHolderForClass.getScope(c.getKotlinTypeChecker().getKotlinTypeRefiner()); + : scopesHolderForClass.getScope(c.getKotlinTypeCheckerOfOwnerModule().getKotlinTypeRefiner()); // essentially, a scope for owner-module return new LazyClassMemberScope( - c, declarationProvider, this, c.getTrace(), kotlinTypeRefiner, + c, declarationProvider, this, c.getTrace(), kotlinTypeRefinerForDependentModule, scopeForDeclaredMembers ); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt index 5eb085fc77f..491012a13b4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt @@ -53,7 +53,7 @@ open class LazyClassMemberScope( declarationProvider: ClassMemberDeclarationProvider, thisClass: ClassDescriptorWithResolutionScopes, trace: BindingTrace, - private val kotlinTypeRefiner: KotlinTypeRefiner = c.kotlinTypeChecker.kotlinTypeRefiner, + private val kotlinTypeRefiner: KotlinTypeRefiner = c.kotlinTypeCheckerOfOwnerModule.kotlinTypeRefiner, scopeForDeclaredMembers: LazyClassMemberScope? = null ) : AbstractLazyMemberScope( c, declarationProvider, thisClass, trace, scopeForDeclaredMembers diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt index 476aaf7f2af..28189c4da73 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt @@ -184,7 +184,7 @@ class LocalClassDescriptorHolder( override val syntheticResolveExtension = this@LocalClassDescriptorHolder.syntheticResolveExtension override val delegationFilter: DelegationFilter = this@LocalClassDescriptorHolder.delegationFilter override val wrappedTypeFactory: WrappedTypeFactory = this@LocalClassDescriptorHolder.wrappedTypeFactory - override val kotlinTypeChecker: NewKotlinTypeChecker = this@LocalClassDescriptorHolder.kotlinTypeChecker + override val kotlinTypeCheckerOfOwnerModule: NewKotlinTypeChecker = this@LocalClassDescriptorHolder.kotlinTypeChecker override val samConversionResolver: SamConversionResolver = this@LocalClassDescriptorHolder.samConversionResolver override val additionalClassPartsProvider: AdditionalClassPartsProvider = this@LocalClassDescriptorHolder.additionalClassPartsProvider diff --git a/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/resolve/LazyScriptDescriptor.kt b/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/resolve/LazyScriptDescriptor.kt index a463288fea9..aa1382c750c 100644 --- a/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/resolve/LazyScriptDescriptor.kt +++ b/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/resolve/LazyScriptDescriptor.kt @@ -148,11 +148,11 @@ class LazyScriptDescriptor( override fun accept(visitor: DeclarationDescriptorVisitor, data: D): R = visitor.visitScriptDescriptor(this, data) - override fun createMemberScope( + override fun createScopesHolderForClass( c: LazyClassContext, declarationProvider: ClassMemberDeclarationProvider ): ScopesHolderForClass = - ScopesHolderForClass.create(this, c.storageManager, c.kotlinTypeChecker.kotlinTypeRefiner) { + ScopesHolderForClass.create(this, c.storageManager, c.kotlinTypeCheckerOfOwnerModule.kotlinTypeRefiner) { LazyScriptClassMemberScope( // Must be a ResolveSession for scripts c as ResolveSession,