azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

SymbolUsageValidator infrastructure

Browse Source
This commit is contained in:
Ilya Ryzhenkov
2015-03-26 16:39:41 +03:00
parent b3aadfd5e0
commit c2b3bcc95f
36 changed files with 268 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java
+6
View File
@@ -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);
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java
+6
View File
@@ -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);
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java
+6
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java
+6
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java
+6
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java
+6
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java
+6
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java
+6
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java
+6
View File
@@ -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
compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java
+2
View File
@@ -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.<CallChecker>newArrayList()),
new CompositeSymbolUsageValidator(),
new AdditionalTypeChecker.Composite(Lists.<AdditionalTypeChecker>newArrayList()),
StatementFilter.NONE);
ArgumentTypeResolver.updateNumberType(defaultType, argumentExpression, context);
compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java
+12 -1
View File
@@ -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<FunctionDescriptor> 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 */
compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java
+17 -3
View File
@@ -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<DeclarationDescriptor> CLASSIFIERS_AND_PACKAGE_VIEWS = new Predicate<DeclarationDescriptor>() {
@Override
public boolean apply(@Nullable DeclarationDescriptor descriptor) {
@@ -257,7 +267,7 @@ public class QualifiedExpressionResolver {
}
@NotNull
private static Collection<DeclarationDescriptor> lookupSelectorDescriptors(
private Collection<DeclarationDescriptor> lookupSelectorDescriptors(
@NotNull JetSimpleNameExpression selector,
@NotNull Collection<DeclarationDescriptor> declarationDescriptors,
@NotNull BindingTrace trace,
@@ -343,7 +353,7 @@ public class QualifiedExpressionResolver {
}
@NotNull
private static Collection<DeclarationDescriptor> filterAndStoreResolutionResult(
private Collection<DeclarationDescriptor> filterAndStoreResolutionResult(
@NotNull Collection<LookupResult> 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<DeclarationDescriptor> descriptors,
@NotNull Collection<DeclarationDescriptor> 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);
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
+9 -5
View File
@@ -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()
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
+2 -2
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java
+10 -9
View File
@@ -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<BasicCallResolutionContext> {
@@ -40,6 +41,7 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
@NotNull ResolutionResultsCache resolutionResultsCache,
@Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
@NotNull CallChecker callChecker,
@NotNull SymbolUsageValidator symbolUsageValidator,
@NotNull AdditionalTypeChecker additionalTypeChecker,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext,
@@ -47,8 +49,7 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
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);
}
@NotNull
@@ -61,12 +62,13 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
@NotNull ContextDependency contextDependency,
@NotNull CheckValueArgumentsMode checkArguments,
@NotNull CallChecker callChecker,
@NotNull SymbolUsageValidator symbolUsageValidator,
@NotNull AdditionalTypeChecker additionalTypeChecker,
boolean isAnnotationContext
) {
return new BasicCallResolutionContext(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
new ResolutionResultsCacheImpl(), null,
callChecker, additionalTypeChecker, StatementFilter.NONE, isAnnotationContext, false, false);
callChecker, symbolUsageValidator, additionalTypeChecker, StatementFilter.NONE, isAnnotationContext, false, false);
}
@NotNull
@@ -76,8 +78,9 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
) {
return new BasicCallResolutionContext(
context.trace, context.scope, call, context.expectedType, context.dataFlowInfo, context.contextDependency, checkArguments,
context.resolutionResultsCache, dataFlowInfoForArguments, context.callChecker, context.additionalTypeChecker, context.statementFilter,
context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
context.resolutionResultsCache, dataFlowInfoForArguments,
context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker,
context.statementFilter, context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
}
@NotNull
@@ -101,15 +104,13 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
) {
return new BasicCallResolutionContext(
trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, isAnnotationContext,
collectAllCandidates, insideSafeCallChain);
dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
}
@NotNull
public BasicCallResolutionContext replaceCall(@NotNull Call newCall) {
return new BasicCallResolutionContext(
trace, scope, newCall, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, isAnnotationContext,
collectAllCandidates, insideCallChain);
dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideCallChain);
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
+6 -4
View File
@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy;
import org.jetbrains.kotlin.resolve.scopes.JetScope;
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.JetType;
public final class CallCandidateResolutionContext<D extends CallableDescriptor> extends CallResolutionContext<CallCandidateResolutionContext<D>> {
@@ -53,6 +54,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
@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<D extends CallableDescriptor>
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<D extends CallableDescriptor>
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<D extends CallableDescriptor>
return new CallCandidateResolutionContext<D>(
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<D extends CallableDescriptor>
) {
return new CallCandidateResolutionContext<D>(
candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
resolutionResultsCache, dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter,
resolutionResultsCache, dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter,
explicitExtensionReceiverForInvoke, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallResolutionContext.java
+4 -1
View File
@@ -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<Context extends CallResolutionContext<Context>> extends ResolutionContext<Context> {
@@ -49,13 +50,15 @@ public abstract class CallResolutionContext<Context extends CallResolutionContex
@SuppressWarnings("NullableProblems")
@Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
@NotNull CallChecker callChecker,
SymbolUsageValidator symbolUsageValidator,
@NotNull AdditionalTypeChecker additionalTypeChecker,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext,
boolean collectAllCandidates,
boolean insideSafeCallChain
) {
super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, additionalTypeChecker,
super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, symbolUsageValidator,
additionalTypeChecker,
statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
this.call = call;
this.checkArguments = checkArguments;
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/ResolutionContext.java
+5
View File
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker;
import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
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;
import org.jetbrains.kotlin.types.TypeUtils;
@@ -49,6 +50,8 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
@NotNull
public final CallChecker callChecker;
@NotNull
public final SymbolUsageValidator symbolUsageValidator;
@NotNull
public final StatementFilter statementFilter;
public final AdditionalTypeChecker additionalTypeChecker;
@@ -68,6 +71,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull CallChecker callChecker,
@NotNull SymbolUsageValidator symbolUsageValidator,
@NotNull AdditionalTypeChecker additionalTypeChecker,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext,
@@ -81,6 +85,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
this.contextDependency = contextDependency;
this.resolutionResultsCache = resolutionResultsCache;
this.callChecker = callChecker;
this.symbolUsageValidator = symbolUsageValidator;
this.statementFilter = statementFilter;
this.additionalTypeChecker = additionalTypeChecker;
this.isAnnotationContext = isAnnotationContext;
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/SimpleResolutionContext.java
+8 -3
View File
@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker;
import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
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 SimpleResolutionContext extends ResolutionContext<SimpleResolutionContext> {
@@ -34,13 +35,15 @@ public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionC
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull CallChecker callChecker,
@NotNull SymbolUsageValidator symbolUsageValidator,
@NotNull AdditionalTypeChecker additionalTypeChecker,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext,
boolean collectAllCandidates,
boolean insideSafeCallChain
) {
super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, additionalTypeChecker,
super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, symbolUsageValidator,
additionalTypeChecker,
statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
}
@@ -51,11 +54,12 @@ public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionC
@NotNull DataFlowInfo dataFlowInfo,
@NotNull ContextDependency contextDependency,
@NotNull CallChecker callChecker,
@NotNull SymbolUsageValidator symbolUsageValidator,
@NotNull AdditionalTypeChecker additionalTypeChecker,
@NotNull StatementFilter statementFilter
) {
this(trace, scope, expectedType, dataFlowInfo, contextDependency, new ResolutionResultsCacheImpl(),
callChecker, additionalTypeChecker, statementFilter, false, false, false);
callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, false, false, false);
}
@Override
@@ -71,7 +75,8 @@ public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionC
boolean insideSafeCallChain
) {
return new SimpleResolutionContext(
trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, additionalTypeChecker,
trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache,
callChecker, symbolUsageValidator, additionalTypeChecker,
statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java
+11 -4
View File
@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
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;
import java.util.Collection;
@@ -57,6 +58,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
@NotNull ResolutionResultsCache resolutionResultsCache,
@Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
@NotNull CallChecker callChecker,
@NotNull SymbolUsageValidator symbolUsageValidator,
@NotNull AdditionalTypeChecker additionalTypeChecker,
@NotNull StatementFilter statementFilter,
@NotNull Collection<MutableResolvedCall<F>> resolvedCalls,
@@ -65,7 +67,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> 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<D extends CallableDescriptor, F extends D> 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.<MutableResolvedCall<F>>newArrayList(),
context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker,
context.statementFilter, Lists.<MutableResolvedCall<F>>newArrayList(),
context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
}
@@ -125,7 +128,9 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
) {
return new ResolutionTask<D, F>(
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<D extends CallableDescriptor, F extends D> extends C
public ResolutionTask<D, F> replaceCall(@NotNull Call newCall) {
return new ResolutionTask<D, F>(
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);
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt
+10 -5
View File
@@ -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
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/CompositeSymbolUsageValidator.kt
+20
View File
@@ -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>) : 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) }
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DefaultSymbolUsageValidator.kt
+3
View File
@@ -0,0 +1,3 @@
package org.jetbrains.kotlin.resolve.validation
object DefaultSymbolUsageValidator : CompositeSymbolUsageValidator()
compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt
+19
View File
@@ -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) {
}
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
+12 -2
View File
@@ -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);
}
}
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java
+7
View File
@@ -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;
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java
+12 -4
View File
@@ -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<ExpressionTypingContext> {
@@ -56,6 +57,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
return newContext(trace, scope, dataFlowInfo, expectedType,
ContextDependency.INDEPENDENT, new ResolutionResultsCacheImpl(),
callChecker != null ? callChecker : expressionTypingServices.getCallChecker(),
expressionTypingServices.getSymbolUsageValidator(),
expressionTypingServices.getAdditionalTypeChecker(),
StatementFilter.NONE, false);
}
@@ -64,7 +66,8 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
public static ExpressionTypingContext newContext(@NotNull ResolutionContext context) {
return new ExpressionTypingContext(
context.trace, context.scope, context.dataFlowInfo, context.expectedType,
context.contextDependency, context.resolutionResultsCache, context.callChecker, context.additionalTypeChecker,
context.contextDependency, context.resolutionResultsCache,
context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker,
context.statementFilter,
context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain
);
@@ -79,12 +82,14 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull CallChecker callChecker,
@NotNull SymbolUsageValidator symbolUsageValidator,
@NotNull AdditionalTypeChecker additionalTypeChecker,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext
) {
return new ExpressionTypingContext(
trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, callChecker, additionalTypeChecker,
trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, callChecker, symbolUsageValidator,
additionalTypeChecker,
statementFilter, isAnnotationContext, false, false);
}
@@ -98,13 +103,15 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull CallChecker callChecker,
@NotNull SymbolUsageValidator symbolUsageValidator,
@NotNull AdditionalTypeChecker additionalTypeChecker,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext,
boolean collectAllCandidates,
boolean insideSafeCallChain
) {
super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, additionalTypeChecker,
super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache,
callChecker, symbolUsageValidator, additionalTypeChecker,
statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
}
@@ -121,7 +128,8 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
boolean insideSafeCallChain
) {
return new ExpressionTypingContext(trace, scope, dataFlowInfo,
expectedType, contextDependency, resolutionResultsCache, callChecker, additionalTypeChecker,
expectedType, contextDependency, resolutionResultsCache,
callChecker, symbolUsageValidator, additionalTypeChecker,
statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java
+6
View File
@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluat
import org.jetbrains.kotlin.resolve.scopes.JetScope;
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.ErrorUtils;
import org.jetbrains.kotlin.types.JetType;
import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage;
@@ -461,6 +462,11 @@ public class ExpressionTypingServices {
return new CompositeChecker(checkers);
}
@NotNull
public SymbolUsageValidator getSymbolUsageValidator() {
return expressionTypingComponents.symbolUsageValidator;
}
@NotNull
public AdditionalTypeChecker getAdditionalTypeChecker() {
List<AdditionalTypeChecker> checkers = expressionTypingComponents.additionalCheckerProvider.getAdditionalTypeCheckers();
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
+5 -1
View File
@@ -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)) {
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java
+6 -2
View File
@@ -80,8 +80,10 @@ public class ForLoopConventionsChecker {
if (iteratorResolutionResults.isSuccess()) {
ResolvedCall<FunctionDescriptor> 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<FunctionDescriptor> 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;
}
compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt
+1 -1
View File
@@ -6,6 +6,6 @@ trait Tr<T> {
}
fun test(t: Tr<*>) {
<!SETTER_PROJECTED_OUT!>t.v<!> = null!!
t.<!SETTER_PROJECTED_OUT!>v<!> = null!!
t.v checkType { it : _<Any?> }
}
compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt
+1 -1
View File
@@ -4,5 +4,5 @@ trait Tr<T> {
}
fun test(t: Tr<out String>) {
<!SETTER_PROJECTED_OUT!>t.v<!> += null!!
t.<!SETTER_PROJECTED_OUT!>v<!> += null!!
}
compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java
+6
View File
@@ -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
generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt
+8
View File
@@ -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<NoFileScopeProvider>()
field<DeclarationScopeProviderForLocalClassifierAnalyzer>()
field<LocalLazyDeclarationResolver>()
field<DefaultSymbolUsageValidator>()
}
private fun generatorForLazyBodyResolve() =
@@ -118,6 +120,7 @@ private fun generatorForLazyBodyResolve() =
parameter<DynamicTypesSettings>()
field<ModuleDescriptor>(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true)
field<DefaultSymbolUsageValidator>()
publicField<LazyTopDownAnalyzerForTopLevel>()
}
@@ -211,6 +214,7 @@ private fun generatorForMacro() =
init = GivenExpression("org.jetbrains.kotlin.context.ContextPackage.GlobalContext()"))
field<AdditionalCheckerProvider.DefaultProvider>()
field<DefaultSymbolUsageValidator>()
}
private fun generatorForTests() =
@@ -228,6 +232,7 @@ private fun generatorForTests() =
useAsContext = true)
field<KotlinJvmCheckerProvider>()
field<DefaultSymbolUsageValidator>()
}
private fun generatorForBodyResolve() =
@@ -240,6 +245,7 @@ private fun generatorForBodyResolve() =
parameter<StatementFilter>()
publicField<BodyResolver>()
field<DefaultSymbolUsageValidator>()
}
private fun generatorForLazyResolve() =
@@ -256,6 +262,7 @@ private fun generatorForLazyResolve() =
field<ScopeProvider>()
field<LazyResolveToken>()
field<DefaultSymbolUsageValidator>()
}
private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
@@ -267,6 +274,7 @@ private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
publicField<ResolveSession>()
field<ScopeProvider>()
field<DefaultSymbolUsageValidator>()
}
private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() {
idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
+6 -11
View File
@@ -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)
js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java
+6
View File
@@ -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);