diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java index a59a9f9c10e..a872121e095 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.resolve.lazy.ScopeProvider; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import com.intellij.psi.search.GlobalSearchScope; import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver; import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver; @@ -92,6 +93,7 @@ public class InjectorForLazyResolveWithJava { private final DeclarationProviderFactory declarationProviderFactory; private final ResolveSession resolveSession; private final ScopeProvider scopeProvider; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final GlobalSearchScope moduleContentScope; private final ModuleClassResolver moduleClassResolver; private final JavaDescriptorResolver javaDescriptorResolver; @@ -161,6 +163,7 @@ public class InjectorForLazyResolveWithJava { this.declarationProviderFactory = declarationProviderFactory; this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace); this.scopeProvider = new ScopeProvider(getResolveSession()); + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.moduleContentScope = moduleContentScope; this.moduleClassResolver = moduleClassResolver; this.javaClassFinder = new JavaClassFinderImpl(); @@ -280,6 +283,7 @@ public class InjectorForLazyResolveWithJava { expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); + expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); @@ -297,6 +301,8 @@ public class InjectorForLazyResolveWithJava { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java index 2b2d379eddf..e08a07f9c27 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.resolve.lazy.ScopeProvider; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import com.intellij.psi.search.GlobalSearchScope; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel; @@ -103,6 +104,7 @@ public class InjectorForReplWithJava { private final DeclarationProviderFactory declarationProviderFactory; private final ResolveSession resolveSession; private final ScopeProvider scopeProvider; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final GlobalSearchScope moduleContentScope; private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel; @@ -183,6 +185,7 @@ public class InjectorForReplWithJava { this.declarationProviderFactory = declarationProviderFactory; this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace); this.scopeProvider = new ScopeProvider(getResolveSession()); + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.moduleContentScope = moduleContentScope; this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel(); @@ -330,6 +333,7 @@ public class InjectorForReplWithJava { expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); + expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); @@ -347,6 +351,8 @@ public class InjectorForReplWithJava { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java index 447a4c17493..4e605c168d8 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.resolve.lazy.ScopeProvider; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import com.intellij.psi.search.GlobalSearchScope; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel; @@ -103,6 +104,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final DeclarationProviderFactory declarationProviderFactory; private final ResolveSession resolveSession; private final ScopeProvider scopeProvider; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final GlobalSearchScope moduleContentScope; private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel; @@ -182,6 +184,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.declarationProviderFactory = declarationProviderFactory; this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace); this.scopeProvider = new ScopeProvider(getResolveSession()); + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.moduleContentScope = moduleContentScope; this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel(); @@ -329,6 +332,7 @@ public class InjectorForTopDownAnalyzerForJvm { expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); + expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); @@ -346,6 +350,8 @@ public class InjectorForTopDownAnalyzerForJvm { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java index 6b29690a14c..045a46d4db6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; import org.jetbrains.kotlin.resolve.StatementFilter; import org.jetbrains.kotlin.resolve.BodyResolver; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver; @@ -70,6 +71,7 @@ public class InjectorForBodyResolve { private final AdditionalCheckerProvider additionalCheckerProvider; private final StatementFilter statementFilter; private final BodyResolver bodyResolver; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -116,6 +118,7 @@ public class InjectorForBodyResolve { this.additionalCheckerProvider = additionalCheckerProvider; this.statementFilter = statementFilter; this.bodyResolver = new BodyResolver(); + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); @@ -191,6 +194,7 @@ public class InjectorForBodyResolve { expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); + expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); @@ -208,6 +212,8 @@ public class InjectorForBodyResolve { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java index 70adb81e0c5..7f09b97e489 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; import org.jetbrains.kotlin.types.DynamicTypesSettings; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel; import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider; import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl; @@ -82,6 +83,7 @@ public class InjectorForLazyBodyResolve { private final DynamicTypesSettings dynamicTypesSettings; private final KotlinBuiltIns kotlinBuiltIns; private final PlatformToKotlinClassMap platformToKotlinClassMap; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel; private final AdditionalFileScopeProvider additionalFileScopeProvider; private final DeclarationScopeProviderImpl declarationScopeProvider; @@ -139,6 +141,7 @@ public class InjectorForLazyBodyResolve { this.dynamicTypesSettings = dynamicTypesSettings; this.kotlinBuiltIns = moduleDescriptor.getBuiltIns(); this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel(); this.additionalFileScopeProvider = new AdditionalFileScopeProvider(); this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace); @@ -244,6 +247,7 @@ public class InjectorForLazyBodyResolve { expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); + expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); @@ -261,6 +265,8 @@ public class InjectorForLazyBodyResolve { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java index 74d067647c3..9a3d593f45f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java @@ -31,6 +31,7 @@ import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider; import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider; import org.jetbrains.kotlin.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer; import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import org.jetbrains.kotlin.resolve.BodyResolver; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; @@ -85,6 +86,7 @@ public class InjectorForLazyLocalClassifierAnalyzer { private final NoFileScopeProvider noFileScopeProvider; private final DeclarationScopeProviderForLocalClassifierAnalyzer declarationScopeProviderForLocalClassifierAnalyzer; private final LocalLazyDeclarationResolver localLazyDeclarationResolver; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final BodyResolver bodyResolver; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -142,6 +144,7 @@ public class InjectorForLazyLocalClassifierAnalyzer { this.noFileScopeProvider = NoFileScopeProvider.INSTANCE$; this.localLazyDeclarationResolver = new LocalLazyDeclarationResolver(globalContext, bindingTrace, localClassDescriptorHolder); this.declarationScopeProviderForLocalClassifierAnalyzer = new DeclarationScopeProviderForLocalClassifierAnalyzer(localLazyDeclarationResolver, localClassDescriptorHolder); + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.bodyResolver = new BodyResolver(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -239,6 +242,7 @@ public class InjectorForLazyLocalClassifierAnalyzer { expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); + expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); @@ -256,6 +260,8 @@ public class InjectorForLazyLocalClassifierAnalyzer { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java index 44a9d338289..d3f6ae6c97e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings; import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.resolve.lazy.ScopeProvider; import org.jetbrains.kotlin.context.LazyResolveToken; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver; @@ -75,6 +76,7 @@ public class InjectorForLazyResolve { private final ResolveSession resolveSession; private final ScopeProvider scopeProvider; private final LazyResolveToken lazyResolveToken; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -124,6 +126,7 @@ public class InjectorForLazyResolve { this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace); this.scopeProvider = new ScopeProvider(getResolveSession()); this.lazyResolveToken = new LazyResolveToken(); + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); @@ -201,6 +204,7 @@ public class InjectorForLazyResolve { expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); + expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); @@ -218,6 +222,8 @@ public class InjectorForLazyResolve { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java index d49e7844820..506a900d080 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.resolve.lazy.ScopeProvider; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel; import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider.DefaultProvider; import org.jetbrains.kotlin.resolve.AnnotationResolver; @@ -83,6 +84,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { private final DeclarationProviderFactory declarationProviderFactory; private final ResolveSession resolveSession; private final ScopeProvider scopeProvider; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel; private final DefaultProvider defaultProvider; private final AnnotationResolver annotationResolver; @@ -141,6 +143,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { this.declarationProviderFactory = declarationProviderFactory; this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace); this.scopeProvider = new ScopeProvider(getResolveSession()); + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel(); this.defaultProvider = DefaultProvider.INSTANCE$; this.annotationResolver = new AnnotationResolver(); @@ -235,6 +238,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); + expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); @@ -252,6 +256,8 @@ public class InjectorForLazyTopDownAnalyzerBasic { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java index 6d153d77e77..0677c20bbc5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.resolve.TypeResolver; import org.jetbrains.kotlin.context.GlobalContext; import org.jetbrains.kotlin.storage.StorageManager; import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider.DefaultProvider; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; import org.jetbrains.kotlin.resolve.DescriptorResolver; @@ -64,6 +65,7 @@ public class InjectorForMacros { private final GlobalContext globalContext; private final StorageManager storageManager; private final DefaultProvider defaultProvider; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final AnnotationResolver annotationResolver; private final CallExpressionResolver callExpressionResolver; private final DescriptorResolver descriptorResolver; @@ -104,6 +106,7 @@ public class InjectorForMacros { this.dynamicTypesSettings = new DynamicTypesSettings(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings); this.defaultProvider = DefaultProvider.INSTANCE$; + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); @@ -141,6 +144,7 @@ public class InjectorForMacros { this.expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); this.expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); this.expressionTypingComponents.setReflectionTypes(reflectionTypes); + this.expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); this.callResolver.setArgumentTypeResolver(argumentTypeResolver); this.callResolver.setCallCompleter(callCompleter); @@ -177,6 +181,8 @@ public class InjectorForMacros { candidateResolver.setArgumentTypeResolver(argumentTypeResolver); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + } @PreDestroy diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java index 3190fbcac58..4a0f3aecedf 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java @@ -50,6 +50,7 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationDescriptor; import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationsContextImpl; import org.jetbrains.kotlin.resolve.scopes.JetScope; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; +import org.jetbrains.kotlin.resolve.validation.CompositeSymbolUsageValidator; import org.jetbrains.kotlin.storage.StorageManager; import org.jetbrains.kotlin.types.ErrorUtils; import org.jetbrains.kotlin.types.JetType; @@ -365,6 +366,7 @@ public class AnnotationResolver { new SimpleResolutionContext(trace, JetScope.Empty.INSTANCE$, NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, ContextDependency.INDEPENDENT, new CompositeChecker(Lists.newArrayList()), + new CompositeSymbolUsageValidator(), new AdditionalTypeChecker.Composite(Lists.newArrayList()), StatementFilter.NONE); ArgumentTypeResolver.updateNumberType(defaultType, argumentExpression, context); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java index 4813c60b7d9..d0d2eb2a08d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.resolve; import com.google.common.collect.Lists; +import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; @@ -208,7 +209,17 @@ public class DelegatedPropertyResolver { return; } - trace.record(DELEGATED_PROPERTY_RESOLVED_CALL, accessor, functionResults.getResultingCall()); + ResolvedCall resultingCall = functionResults.getResultingCall(); + PsiElement declaration = DescriptorToSourceUtils.descriptorToDeclaration(propertyDescriptor); + if (declaration instanceof JetProperty) { + JetProperty property = (JetProperty) declaration; + JetPropertyDelegate delegate = property.getDelegate(); + if (delegate != null) { + PsiElement byKeyword = delegate.getByKeywordNode().getPsi(); + expressionTypingServices.getSymbolUsageValidator().validateCall(resultingCall.getResultingDescriptor(), trace, byKeyword); + } + } + trace.record(DELEGATED_PROPERTY_RESOLVED_CALL, accessor, resultingCall); } /* Resolve get() or set() methods from delegate */ diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java index 1d52ae99957..d525ad234a5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java @@ -29,10 +29,13 @@ import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.diagnostics.Errors; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; +import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.scopes.AbstractScopeAdapter; import org.jetbrains.kotlin.resolve.scopes.JetScope; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; +import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; +import javax.inject.Inject; import java.util.Collection; import java.util.Collections; import java.util.Set; @@ -40,6 +43,13 @@ import java.util.Set; import static org.jetbrains.kotlin.diagnostics.Errors.*; public class QualifiedExpressionResolver { + private SymbolUsageValidator symbolUsageValidator; + + @Inject + public void setSymbolUsageValidator(SymbolUsageValidator symbolUsageValidator) { + this.symbolUsageValidator = symbolUsageValidator; + } + private static final Predicate CLASSIFIERS_AND_PACKAGE_VIEWS = new Predicate() { @Override public boolean apply(@Nullable DeclarationDescriptor descriptor) { @@ -257,7 +267,7 @@ public class QualifiedExpressionResolver { } @NotNull - private static Collection lookupSelectorDescriptors( + private Collection lookupSelectorDescriptors( @NotNull JetSimpleNameExpression selector, @NotNull Collection declarationDescriptors, @NotNull BindingTrace trace, @@ -343,7 +353,7 @@ public class QualifiedExpressionResolver { } @NotNull - private static Collection filterAndStoreResolutionResult( + private Collection filterAndStoreResolutionResult( @NotNull Collection lookupResults, @NotNull JetSimpleNameExpression referenceExpression, @NotNull BindingTrace trace, @@ -397,7 +407,7 @@ public class QualifiedExpressionResolver { return filteredDescriptors; } - private static void storeResolutionResult( + private void storeResolutionResult( @NotNull Collection descriptors, @NotNull Collection canBeImportedDescriptors, @NotNull JetSimpleNameExpression referenceExpression, @@ -435,6 +445,10 @@ public class QualifiedExpressionResolver { trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, descriptors.iterator().next()); trace.record(BindingContext.RESOLUTION_SCOPE, referenceExpression, resolutionScope); + if (descriptor instanceof ClassifierDescriptor) { + symbolUsageValidator.validateTypeUsage((ClassifierDescriptor) descriptor, trace, referenceExpression); + } + if (descriptor instanceof DeclarationDescriptorWithVisibility) { checkVisibility((DeclarationDescriptorWithVisibility) descriptor, trace, referenceExpression, scopeToCheckVisibility); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt index cb1729209b8..906e8172e3a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy import org.jetbrains.kotlin.resolve.calls.context.CheckValueArgumentsMode -import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall import org.jetbrains.kotlin.types.JetType import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem @@ -33,10 +32,7 @@ import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData import org.jetbrains.kotlin.psi.ValueArgument -import org.jetbrains.kotlin.resolve.calls.model.ArgumentMapping import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo -import org.jetbrains.kotlin.resolve.calls.model.ArgumentUnmapped -import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext import org.jetbrains.kotlin.resolve.calls.callUtil.* @@ -52,6 +48,7 @@ import org.jetbrains.kotlin.resolve.TemporaryBindingTrace import org.jetbrains.kotlin.psi.JetQualifiedExpression import java.util.ArrayList import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.* +import org.jetbrains.kotlin.resolve.calls.model.* public class CallCompleter( val argumentTypeResolver: ArgumentTypeResolver, @@ -78,7 +75,14 @@ public class CallCompleter( temporaryTrace.commit() } - resolvedCall?.let { context.callChecker.check(it, context) } + if (resolvedCall != null) { + context.callChecker.check(resolvedCall, context) + val element = if (resolvedCall is VariableAsFunctionResolvedCall) + resolvedCall.variableCall.getCall().getCalleeExpression() + else + resolvedCall.getCall().getCalleeExpression() + context.symbolUsageValidator.validateCall(resolvedCall.getResultingDescriptor(), context.trace, element) + } if (results.isSingleResult() && results.getResultingCall().getStatus().isSuccess()) { return results.changeStatusToSuccess() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java index 1052b76ea9b..4a7408fdd82 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -232,7 +232,7 @@ public class CallResolver { return resolveFunctionCall( BasicCallResolutionContext.create( trace, scope, call, expectedType, dataFlowInfo, ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED, - expressionTypingServices.getCallChecker(), expressionTypingServices.getAdditionalTypeChecker(), isAnnotationContext) + expressionTypingServices.getCallChecker(), expressionTypingServices.getSymbolUsageValidator(), expressionTypingServices.getAdditionalTypeChecker(), isAnnotationContext) ); } @@ -312,7 +312,7 @@ public class CallResolver { CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, dataFlowInfo, ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED, - callChecker, expressionTypingServices.getAdditionalTypeChecker(), false); + callChecker, expressionTypingServices.getSymbolUsageValidator(), expressionTypingServices.getAdditionalTypeChecker(), false); if (call.getCalleeExpression() == null) return checkArgumentTypesAndFail(context); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java index 008f3e9124d..04602ae305a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker; import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.scopes.JetScope; +import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; import org.jetbrains.kotlin.types.JetType; public class BasicCallResolutionContext extends CallResolutionContext { @@ -40,6 +41,7 @@ public class BasicCallResolutionContext extends CallResolutionContext extends CallResolutionContext> { @@ -53,6 +54,7 @@ public final class CallCandidateResolutionContext @NotNull ResolutionResultsCache resolutionResultsCache, @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments, @NotNull CallChecker callChecker, + @NotNull SymbolUsageValidator symbolUsageValidator, @NotNull AdditionalTypeChecker additionalTypeChecker, @NotNull StatementFilter statementFilter, @NotNull ReceiverValue explicitExtensionReceiverForInvoke, @@ -61,7 +63,7 @@ public final class CallCandidateResolutionContext boolean insideSafeCallChain ) { super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache, - dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, isAnnotationContext, + dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain); this.candidateCall = candidateCall; this.tracing = tracing; @@ -77,7 +79,7 @@ public final class CallCandidateResolutionContext candidateCall, tracing, trace, context.scope, call, context.expectedType, context.dataFlowInfo, context.contextDependency, context.checkArguments, context.resolutionResultsCache, context.dataFlowInfoForArguments, - context.callChecker, context.additionalTypeChecker, context.statementFilter, explicitExtensionReceiverForInvoke, + context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker, context.statementFilter, explicitExtensionReceiverForInvoke, context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain); } @@ -101,7 +103,7 @@ public final class CallCandidateResolutionContext return new CallCandidateResolutionContext( candidateCall, tracing, context.trace, context.scope, context.call, context.expectedType, context.dataFlowInfo, context.contextDependency, context.checkArguments, context.resolutionResultsCache, - context.dataFlowInfoForArguments, context.callChecker, context.additionalTypeChecker, context.statementFilter, + context.dataFlowInfoForArguments, context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker, context.statementFilter, ReceiverValue.NO_RECEIVER, context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain); } @@ -119,7 +121,7 @@ public final class CallCandidateResolutionContext ) { return new CallCandidateResolutionContext( candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, - resolutionResultsCache, dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, + resolutionResultsCache, dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, explicitExtensionReceiverForInvoke, isAnnotationContext, collectAllCandidates, insideSafeCallChain); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallResolutionContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallResolutionContext.java index bd27d95ff85..70ecaec49ab 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallResolutionContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallResolutionContext.java @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.resolve.calls.model.DataFlowInfoForArgumentsImpl; import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.scopes.JetScope; +import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; import org.jetbrains.kotlin.types.JetType; public abstract class CallResolutionContext> extends ResolutionContext { @@ -49,13 +50,15 @@ public abstract class CallResolutionContext { @@ -34,13 +35,15 @@ public class SimpleResolutionContext extends ResolutionContext extends C @NotNull ResolutionResultsCache resolutionResultsCache, @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments, @NotNull CallChecker callChecker, + @NotNull SymbolUsageValidator symbolUsageValidator, @NotNull AdditionalTypeChecker additionalTypeChecker, @NotNull StatementFilter statementFilter, @NotNull Collection> resolvedCalls, @@ -65,7 +67,7 @@ public class ResolutionTask extends C boolean insideSafeCallChain ) { super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache, - dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain); + dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain); this.lazyCandidates = lazyCandidates; this.resolvedCalls = resolvedCalls; this.tracing = tracing; @@ -80,7 +82,8 @@ public class ResolutionTask extends C context.trace, context.scope, context.call, context.expectedType, context.dataFlowInfo, context.contextDependency, context.checkArguments, context.resolutionResultsCache, context.dataFlowInfoForArguments, - context.callChecker, context.additionalTypeChecker, context.statementFilter, Lists.>newArrayList(), + context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker, + context.statementFilter, Lists.>newArrayList(), context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain); } @@ -125,7 +128,9 @@ public class ResolutionTask extends C ) { return new ResolutionTask( lazyCandidates, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, - resolutionResultsCache, dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, resolvedCalls, + resolutionResultsCache, dataFlowInfoForArguments, + callChecker, symbolUsageValidator, additionalTypeChecker, + statementFilter, resolvedCalls, isAnnotationContext, collectAllCandidates, insideSafeCallChain); } @@ -136,7 +141,9 @@ public class ResolutionTask extends C public ResolutionTask replaceCall(@NotNull Call newCall) { return new ResolutionTask( lazyCandidates, tracing, trace, scope, newCall, expectedType, dataFlowInfo, contextDependency, checkArguments, - resolutionResultsCache, dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, resolvedCalls, + resolutionResultsCache, dataFlowInfoForArguments, + callChecker, symbolUsageValidator, additionalTypeChecker, + statementFilter, resolvedCalls, isAnnotationContext, collectAllCandidates, insideCallChain); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt index 25c3a6bc17f..8aa8308fb94 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt @@ -32,7 +32,6 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.DescriptorUtils.getFqName import org.jetbrains.kotlin.resolve.bindingContextUtil.recordScopeAndDataFlowInfo import org.jetbrains.kotlin.resolve.descriptorUtil.classObjectType -import org.jetbrains.kotlin.resolve.descriptorUtil.getClassObjectReferenceTarget import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassObjectType import org.jetbrains.kotlin.resolve.scopes.ChainedScope import org.jetbrains.kotlin.resolve.scopes.FilteringScope @@ -182,12 +181,18 @@ private fun QualifierReceiver.resolveReferenceTarget( val isCallableWithReceiver = selector is CallableDescriptor && (selector.getDispatchReceiverParameter() != null || selector.getExtensionReceiverParameter() != null) - if (classifier is ClassDescriptor && classifier.hasClassObjectType && isCallableWithReceiver) { - if (classifier.getCompanionObjectDescriptor() != null) { + val declarationDescriptor = descriptor + if (declarationDescriptor is ClassifierDescriptor) + context.symbolUsageValidator.validateTypeUsage(declarationDescriptor, context.trace, referenceExpression) + + if (isCallableWithReceiver && classifier is ClassDescriptor && classifier.hasClassObjectType) { + val companionObjectDescriptor = classifier.getCompanionObjectDescriptor() + if (companionObjectDescriptor != null) { context.trace.record(SHORT_REFERENCE_TO_COMPANION_OBJECT, referenceExpression, classifier) + context.symbolUsageValidator.validateTypeUsage(companionObjectDescriptor, context.trace, referenceExpression) + return companionObjectDescriptor } - return classifier.getClassObjectReferenceTarget() } - return descriptor + return declarationDescriptor } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/CompositeSymbolUsageValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/CompositeSymbolUsageValidator.kt new file mode 100644 index 00000000000..981bc4781f3 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/CompositeSymbolUsageValidator.kt @@ -0,0 +1,20 @@ +package org.jetbrains.kotlin.resolve.validation + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.ClassifierDescriptor +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall + +public open class CompositeSymbolUsageValidator(val validators: List) : SymbolUsageValidator { + + constructor(vararg validator : SymbolUsageValidator) : this(validator.toList()) {} + + override fun validateCall(targetDescriptor: CallableDescriptor, trace: BindingTrace, element: PsiElement) { + validators.forEach { it.validateCall(targetDescriptor, trace, element) } + } + + override fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) { + validators.forEach { it.validateTypeUsage(targetDescriptor, trace, element) } + } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DefaultSymbolUsageValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DefaultSymbolUsageValidator.kt new file mode 100644 index 00000000000..839e9ea6792 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DefaultSymbolUsageValidator.kt @@ -0,0 +1,3 @@ +package org.jetbrains.kotlin.resolve.validation + +object DefaultSymbolUsageValidator : CompositeSymbolUsageValidator() \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt new file mode 100644 index 00000000000..2cd35f62959 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt @@ -0,0 +1,19 @@ +package org.jetbrains.kotlin.resolve.validation + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.ClassifierDescriptor +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall + +public trait SymbolUsageValidator { + + fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) { + + } + + fun validateCall(targetDescriptor: CallableDescriptor, trace: BindingTrace, element: PsiElement) { + + } + +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index 45d99db133d..c57973defd2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -62,6 +62,7 @@ import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl; import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver; +import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; import org.jetbrains.kotlin.types.*; import org.jetbrains.kotlin.types.checker.JetTypeChecker; import org.jetbrains.kotlin.util.slicedMap.WritableSlice; @@ -436,8 +437,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { trace.record(RESOLVED_CALL, call, resolvedCall); trace.record(CALL, expression, call); - context.callChecker.check(resolvedCall, - BasicCallResolutionContext.create(context, call, CheckValueArgumentsMode.DISABLED)); + BasicCallResolutionContext resolutionContext = BasicCallResolutionContext.create(context, call, CheckValueArgumentsMode.DISABLED); + context.callChecker.check(resolvedCall, resolutionContext); + context.symbolUsageValidator.validateCall(descriptor, trace, expression); } private static boolean isDeclaredInClass(ReceiverParameterDescriptor receiver) { @@ -1006,11 +1008,19 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { boolean result = true; JetExpression reportOn = expression != null ? expression : expressionWithParenthesis; + if (reportOn instanceof JetQualifiedExpression) + reportOn = ((JetQualifiedExpression)reportOn).getSelectorExpression(); + if (variable instanceof PropertyDescriptor) { PropertyDescriptor propertyDescriptor = (PropertyDescriptor) variable; + PropertySetterDescriptor setter = propertyDescriptor.getSetter(); if (propertyDescriptor.isSetterProjectedOut()) { trace.report(SETTER_PROJECTED_OUT.on(reportOn, propertyDescriptor)); result = false; + } else { + if (setter != null) { + context.symbolUsageValidator.validateCall(setter, trace, reportOn); + } } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java index 2f035c37490..64c94caa721 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.context.GlobalContext; import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; import org.jetbrains.kotlin.resolve.calls.CallResolver; +import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; import org.jetbrains.kotlin.types.DynamicTypesSettings; import org.jetbrains.kotlin.builtins.ReflectionTypes; @@ -37,6 +38,7 @@ public class ExpressionTypingComponents { /*package*/ ForLoopConventionsChecker forLoopConventionsChecker; /*package*/ ReflectionTypes reflectionTypes; /*package*/ AdditionalCheckerProvider additionalCheckerProvider; + /*package*/ SymbolUsageValidator symbolUsageValidator; /*package*/ DynamicTypesSettings dynamicTypesSettings; /*package*/ KotlinBuiltIns builtIns; /*package*/ LocalClassifierAnalyzer localClassifierAnalyzer; @@ -86,6 +88,11 @@ public class ExpressionTypingComponents { this.additionalCheckerProvider = additionalCheckerProvider; } + @Inject + public void setSymbolUsageValidator(SymbolUsageValidator symbolUsageValidator) { + this.symbolUsageValidator = symbolUsageValidator; + } + @Inject public void setDynamicTypesSettings(@NotNull DynamicTypesSettings dynamicTypesSettings) { this.dynamicTypesSettings = dynamicTypesSettings; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java index 99e4441c388..e83cffd6166 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.constants.CompileTimeConstantChecker; import org.jetbrains.kotlin.resolve.scopes.JetScope; +import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; import org.jetbrains.kotlin.types.JetType; public class ExpressionTypingContext extends ResolutionContext { @@ -56,6 +57,7 @@ public class ExpressionTypingContext extends ResolutionContext checkers = expressionTypingComponents.additionalCheckerProvider.getAdditionalTypeCheckers(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java index 0abb2bfbe09..f69425de03c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java @@ -262,7 +262,11 @@ public class ExpressionTypingUtils { JetType componentType = null; if (results.isSuccess()) { context.trace.record(COMPONENT_RESOLVED_CALL, entry, results.getResultingCall()); - componentType = results.getResultingDescriptor().getReturnType(); + FunctionDescriptor componentFunction = results.getResultingDescriptor(); + + expressionTypingServices.getSymbolUsageValidator().validateCall(componentFunction, context.trace, entry); + + componentType = componentFunction.getReturnType(); if (componentType != null && !noExpectedType(expectedType) && !JetTypeChecker.DEFAULT.isSubtypeOf(componentType, expectedType)) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java index ea248ec0f62..5b5e15bd324 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java @@ -80,8 +80,10 @@ public class ForLoopConventionsChecker { if (iteratorResolutionResults.isSuccess()) { ResolvedCall iteratorResolvedCall = iteratorResolutionResults.getResultingCall(); context.trace.record(LOOP_RANGE_ITERATOR_RESOLVED_CALL, loopRangeExpression, iteratorResolvedCall); - FunctionDescriptor iteratorFunction = iteratorResolvedCall.getResultingDescriptor(); + + expressionTypingServices.getSymbolUsageValidator().validateCall(iteratorFunction, context.trace, loopRangeExpression); + JetType iteratorType = iteratorFunction.getReturnType(); JetType hasNextType = checkConventionForIterator(context, loopRangeExpression, iteratorType, "hasNext", HAS_NEXT_FUNCTION_AMBIGUITY, HAS_NEXT_MISSING, HAS_NEXT_FUNCTION_NONE_APPLICABLE, @@ -130,7 +132,9 @@ public class ForLoopConventionsChecker { assert nextResolutionResults.isSuccess(); ResolvedCall resolvedCall = nextResolutionResults.getResultingCall(); context.trace.record(resolvedCallKey, loopRangeExpression, resolvedCall); - return resolvedCall.getResultingDescriptor().getReturnType(); + FunctionDescriptor functionDescriptor = resolvedCall.getResultingDescriptor(); + expressionTypingServices.getSymbolUsageValidator().validateCall(functionDescriptor, context.trace, loopRangeExpression); + return functionDescriptor.getReturnType(); } return null; } diff --git a/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt b/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt index 5396cc7c331..0f2c6b5b154 100644 --- a/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt +++ b/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt @@ -6,6 +6,6 @@ trait Tr { } fun test(t: Tr<*>) { - t.v = null!! + t.v = null!! t.v checkType { it : _ } } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt b/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt index 3f3d866c94d..8f92eb93981 100644 --- a/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt +++ b/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt @@ -4,5 +4,5 @@ trait Tr { } fun test(t: Tr) { - t.v += null!! + t.v += null!! } \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java b/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java index 1106077fdee..01f774c5698 100644 --- a/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java @@ -28,6 +28,7 @@ import org.jetbrains.kotlin.resolve.TypeResolver; import org.jetbrains.kotlin.context.GlobalContext; import org.jetbrains.kotlin.storage.StorageManager; import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import org.jetbrains.kotlin.resolve.AnnotationResolver; import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver; @@ -65,6 +66,7 @@ public class InjectorForTests { private final GlobalContext globalContext; private final StorageManager storageManager; private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -107,6 +109,7 @@ public class InjectorForTests { this.callResolver = new CallResolver(); this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), callResolver, kotlinBuiltIns); this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$; + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.argumentTypeResolver = new ArgumentTypeResolver(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -169,6 +172,7 @@ public class InjectorForTests { expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); + expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); @@ -177,6 +181,8 @@ public class InjectorForTests { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + } @PreDestroy diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index 0fcb03add9a..6b84109f3fe 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -44,6 +44,7 @@ import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct import org.jetbrains.kotlin.resolve.lazy.* import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.types.DynamicTypesAllowed import org.jetbrains.kotlin.types.DynamicTypesSettings @@ -106,6 +107,7 @@ private fun generatorForLazyLocalClassifierAnalyzer() = field() field() field() + field() } private fun generatorForLazyBodyResolve() = @@ -118,6 +120,7 @@ private fun generatorForLazyBodyResolve() = parameter() field(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true) + field() publicField() } @@ -211,6 +214,7 @@ private fun generatorForMacro() = init = GivenExpression("org.jetbrains.kotlin.context.ContextPackage.GlobalContext()")) field() + field() } private fun generatorForTests() = @@ -228,6 +232,7 @@ private fun generatorForTests() = useAsContext = true) field() + field() } private fun generatorForBodyResolve() = @@ -240,6 +245,7 @@ private fun generatorForBodyResolve() = parameter() publicField() + field() } private fun generatorForLazyResolve() = @@ -256,6 +262,7 @@ private fun generatorForLazyResolve() = field() field() + field() } private fun DependencyInjectorGenerator.commonForResolveSessionBased() { @@ -267,6 +274,7 @@ private fun DependencyInjectorGenerator.commonForResolveSessionBased() { publicField() field() + field() } private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() { diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt index e09b4d62f5a..68e64e7d178 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt @@ -71,6 +71,7 @@ import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.resolve.validation.CompositeSymbolUsageValidator enum class Tail { COMMA @@ -170,17 +171,11 @@ class ExpectedInfos( val expectedType = (callElement as? JetExpression)?.let { bindingContext[BindingContext.EXPECTED_EXPRESSION_TYPE, it] } ?: TypeUtils.NO_EXPECTED_TYPE val dataFlowInfo = bindingContext.getDataFlowInfo(calleeExpression) - val callResolutionContext = BasicCallResolutionContext.create( - DelegatingBindingTrace(bindingContext, "Temporary trace for completion"), - resolutionScope, - call, - expectedType, - dataFlowInfo, - ContextDependency.INDEPENDENT, - CheckValueArgumentsMode.ENABLED, - CompositeChecker(listOf()), - AdditionalTypeChecker.Composite(listOf()), - false).replaceCollectAllCandidates(true) + val bindingTrace = DelegatingBindingTrace(bindingContext, "Temporary trace for completion") + val context = BasicCallResolutionContext.create(bindingTrace, resolutionScope, call, expectedType, dataFlowInfo, + ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED, + CompositeChecker(listOf()), CompositeSymbolUsageValidator(), AdditionalTypeChecker.Composite(listOf()), false) + val callResolutionContext = context.replaceCollectAllCandidates(true) val callResolver = InjectorForMacros( callElement.getProject(), resolutionFacade.findModuleDescriptor(callElement) diff --git a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java index 3dd6afa8576..ac6431fa58c 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.resolve.lazy.ScopeProvider; +import org.jetbrains.kotlin.resolve.validation.DefaultSymbolUsageValidator; import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel; import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider; import org.jetbrains.kotlin.types.DynamicTypesAllowed; @@ -83,6 +84,7 @@ public class InjectorForTopDownAnalyzerForJs { private final DeclarationProviderFactory declarationProviderFactory; private final ResolveSession resolveSession; private final ScopeProvider scopeProvider; + private final DefaultSymbolUsageValidator defaultSymbolUsageValidator; private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel; private final KotlinJsCheckerProvider kotlinJsCheckerProvider; private final DynamicTypesAllowed dynamicTypesAllowed; @@ -141,6 +143,7 @@ public class InjectorForTopDownAnalyzerForJs { this.declarationProviderFactory = declarationProviderFactory; this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace); this.scopeProvider = new ScopeProvider(getResolveSession()); + this.defaultSymbolUsageValidator = DefaultSymbolUsageValidator.INSTANCE$; this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel(); this.kotlinJsCheckerProvider = KotlinJsCheckerProvider.INSTANCE$; this.dynamicTypesAllowed = new DynamicTypesAllowed(); @@ -235,6 +238,7 @@ public class InjectorForTopDownAnalyzerForJs { expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); expressionTypingComponents.setReflectionTypes(reflectionTypes); + expressionTypingComponents.setSymbolUsageValidator(defaultSymbolUsageValidator); forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); @@ -252,6 +256,8 @@ public class InjectorForTopDownAnalyzerForJs { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator); + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); candidateResolver.setArgumentTypeResolver(argumentTypeResolver);