mirror of
https://github.com/jlengrand/kotlin.git
synced 2026-03-22 00:21:31 +00:00
Compare commits
29 Commits
rr/faster_
...
move-bug-r
| Author | SHA1 | Date | |
|---|---|---|---|
|
eea0474e24 | ||
|
|
3dfc25c7b7 | ||
|
|
0f79ee0d34 | ||
|
|
89799722bf | ||
|
|
273f5b71d2 | ||
|
|
3a2b97210d | ||
|
|
b3ddecabf5 | ||
|
|
8e4f371995 | ||
|
|
482a3871a1 | ||
|
|
5a2a25519a | ||
|
|
f4b86d25fd | ||
|
|
118b7bf256 | ||
|
|
46d1eb8909 | ||
|
|
0973e36145 | ||
|
|
3ac80d26c3 | ||
|
|
4ef2731331 | ||
|
|
7c55ed34f7 | ||
|
|
c6db0ecb00 | ||
|
|
c0954e0c14 | ||
|
|
a437d81438 | ||
|
|
0a6159f220 | ||
|
|
d93dd625a6 | ||
|
|
174f06d581 | ||
|
|
695628686b | ||
|
|
f74fc98f70 | ||
|
|
d8f8c15735 | ||
|
|
80a2b2f262 | ||
|
|
be9b87d00c | ||
|
|
1f217f3eeb |
@@ -58,8 +58,10 @@ import org.jetbrains.kotlin.parsing.JetParserDefinition;
|
||||
import org.jetbrains.kotlin.psi.JetFile;
|
||||
import org.jetbrains.kotlin.psi.JetScript;
|
||||
import org.jetbrains.kotlin.resolve.*;
|
||||
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
|
||||
import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
|
||||
import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo;
|
||||
import org.jetbrains.kotlin.resolve.lazy.declarations.*;
|
||||
@@ -99,6 +101,7 @@ public class ReplInterpreter {
|
||||
|
||||
private final TopDownAnalysisContext topDownAnalysisContext;
|
||||
private final LazyTopDownAnalyzer topDownAnalyzer;
|
||||
private final ResolveSession resolveSession;
|
||||
private final ScriptMutableDeclarationProviderFactory scriptDeclarationFactory;
|
||||
|
||||
public ReplInterpreter(@NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) {
|
||||
@@ -139,8 +142,9 @@ public class ReplInterpreter {
|
||||
scopeProvider
|
||||
);
|
||||
|
||||
this.topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters);
|
||||
this.topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters, DataFlowInfo.EMPTY);
|
||||
this.topDownAnalyzer = injector.getLazyTopDownAnalyzer();
|
||||
this.resolveSession = injector.getResolveSession();
|
||||
|
||||
module.initialize(new CompositePackageFragmentProvider(
|
||||
Arrays.asList(
|
||||
@@ -358,10 +362,12 @@ public class ReplInterpreter {
|
||||
|
||||
TopDownAnalysisContext context = topDownAnalyzer.analyzeDeclarations(
|
||||
topDownAnalysisContext.getTopDownAnalysisParameters(),
|
||||
Collections.singletonList(psiFile));
|
||||
Collections.singletonList(psiFile),
|
||||
DataFlowInfo.EMPTY
|
||||
);
|
||||
|
||||
if (trace.get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, psiFile) == null) {
|
||||
trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, psiFile, topDownAnalyzer.getCodeAnalyzer().getPackageFragment(FqName.ROOT));
|
||||
trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, psiFile, resolveSession.getPackageFragment(FqName.ROOT));
|
||||
}
|
||||
|
||||
boolean hasErrors = AnalyzerWithCompilerReport.reportDiagnostics(trace.getBindingContext().getDiagnostics(), messageCollector);
|
||||
|
||||
@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
|
||||
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 com.intellij.psi.search.GlobalSearchScope;
|
||||
import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver;
|
||||
import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
|
||||
@@ -52,20 +53,21 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings;
|
||||
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver;
|
||||
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver;
|
||||
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
|
||||
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
|
||||
import org.jetbrains.kotlin.psi.JetImportsFactory;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
|
||||
import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext;
|
||||
import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver;
|
||||
@@ -88,6 +90,7 @@ public class InjectorForLazyResolveWithJava {
|
||||
private final PlatformToKotlinClassMap platformToKotlinClassMap;
|
||||
private final DeclarationProviderFactory declarationProviderFactory;
|
||||
private final ResolveSession resolveSession;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final GlobalSearchScope moduleContentScope;
|
||||
private final ModuleClassResolver moduleClassResolver;
|
||||
private final JavaDescriptorResolver javaDescriptorResolver;
|
||||
@@ -115,20 +118,21 @@ public class InjectorForLazyResolveWithJava {
|
||||
private final ExpressionTypingUtils expressionTypingUtils;
|
||||
private final ForLoopConventionsChecker forLoopConventionsChecker;
|
||||
private final LocalClassifierAnalyzer localClassifierAnalyzer;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final DescriptorResolver descriptorResolver;
|
||||
private final DelegatedPropertyResolver delegatedPropertyResolver;
|
||||
private final TypeResolver typeResolver;
|
||||
private final QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final PartialBodyResolveProvider partialBodyResolveProvider;
|
||||
private final CallCompleter callCompleter;
|
||||
private final CandidateResolver candidateResolver;
|
||||
private final TaskPrioritizer taskPrioritizer;
|
||||
private final JetImportsFactory jetImportsFactory;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private final LazyDeclarationResolver lazyDeclarationResolver;
|
||||
private final DeclarationScopeProviderImpl declarationScopeProvider;
|
||||
private final ScriptBodyResolver scriptBodyResolver;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
|
||||
private final GlobalJavaResolverContext globalJavaResolverContext;
|
||||
private final DeserializedDescriptorResolver deserializedDescriptorResolver;
|
||||
@@ -154,6 +158,7 @@ public class InjectorForLazyResolveWithJava {
|
||||
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
|
||||
this.declarationProviderFactory = declarationProviderFactory;
|
||||
this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace);
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.moduleContentScope = moduleContentScope;
|
||||
this.moduleClassResolver = moduleClassResolver;
|
||||
this.javaClassFinder = new JavaClassFinderImpl();
|
||||
@@ -183,21 +188,22 @@ public class InjectorForLazyResolveWithJava {
|
||||
this.dynamicTypesSettings = new DynamicTypesSettings();
|
||||
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.descriptorResolver = new DescriptorResolver();
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
|
||||
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
|
||||
this.candidateResolver = new CandidateResolver();
|
||||
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
|
||||
this.taskPrioritizer = new TaskPrioritizer(storageManager);
|
||||
this.jetImportsFactory = new JetImportsFactory();
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
|
||||
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
|
||||
this.scriptBodyResolver = new ScriptBodyResolver();
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
|
||||
this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, virtualFileFinder, traceBasedErrorReporter);
|
||||
this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
|
||||
@@ -205,11 +211,15 @@ public class InjectorForLazyResolveWithJava {
|
||||
this.resolveSession.setAnnotationResolve(annotationResolver);
|
||||
this.resolveSession.setDescriptorResolver(descriptorResolver);
|
||||
this.resolveSession.setJetImportFactory(jetImportsFactory);
|
||||
this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
this.resolveSession.setScopeProvider(scopeProvider);
|
||||
this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
|
||||
this.resolveSession.setTypeResolver(typeResolver);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
|
||||
javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
|
||||
javaClassFinder.setProject(project);
|
||||
javaClassFinder.setScope(moduleContentScope);
|
||||
@@ -271,8 +281,6 @@ public class InjectorForLazyResolveWithJava {
|
||||
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
|
||||
forLoopConventionsChecker.setProject(project);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
descriptorResolver.setAnnotationResolver(annotationResolver);
|
||||
descriptorResolver.setBuiltIns(kotlinBuiltIns);
|
||||
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
|
||||
@@ -284,11 +292,16 @@ public class InjectorForLazyResolveWithJava {
|
||||
delegatedPropertyResolver.setCallResolver(callResolver);
|
||||
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
|
||||
|
||||
jetImportsFactory.setProject(project);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
|
||||
|
||||
declarationScopeProvider.setFileScopeProvider(scopeProvider);
|
||||
|
||||
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
|
||||
@@ -25,8 +25,10 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
|
||||
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 com.intellij.psi.search.GlobalSearchScope;
|
||||
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
|
||||
import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
|
||||
import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava;
|
||||
import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder;
|
||||
@@ -39,7 +41,6 @@ import org.jetbrains.kotlin.load.java.components.PsiBasedExternalAnnotationResol
|
||||
import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
|
||||
import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl;
|
||||
import org.jetbrains.kotlin.load.java.components.JavaSourceElementFactoryImpl;
|
||||
import org.jetbrains.kotlin.resolve.MutablePackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
|
||||
import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
|
||||
import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
|
||||
@@ -55,19 +56,20 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings;
|
||||
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver;
|
||||
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver;
|
||||
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
|
||||
import org.jetbrains.kotlin.context.LazinessToken;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
|
||||
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
|
||||
import org.jetbrains.kotlin.psi.JetImportsFactory;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
|
||||
import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.BodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
|
||||
@@ -75,12 +77,8 @@ import org.jetbrains.kotlin.resolve.DeclarationsChecker;
|
||||
import org.jetbrains.kotlin.resolve.ModifiersChecker;
|
||||
import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
|
||||
import org.jetbrains.kotlin.resolve.DeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.ImportsResolver;
|
||||
import org.jetbrains.kotlin.resolve.OverloadResolver;
|
||||
import org.jetbrains.kotlin.resolve.OverrideResolver;
|
||||
import org.jetbrains.kotlin.resolve.TopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.TypeHierarchyResolver;
|
||||
import org.jetbrains.kotlin.resolve.ScriptHeaderResolver;
|
||||
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
|
||||
import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext;
|
||||
@@ -103,8 +101,10 @@ public class InjectorForReplWithJava {
|
||||
private final PlatformToKotlinClassMap platformToKotlinClassMap;
|
||||
private final DeclarationProviderFactory declarationProviderFactory;
|
||||
private final ResolveSession resolveSession;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final GlobalSearchScope moduleContentScope;
|
||||
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
|
||||
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
|
||||
private final JavaDescriptorResolver javaDescriptorResolver;
|
||||
private final DeserializationComponentsForJava deserializationComponentsForJava;
|
||||
private final VirtualFileFinder virtualFileFinder;
|
||||
@@ -117,7 +117,6 @@ public class InjectorForReplWithJava {
|
||||
private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
|
||||
private final SamConversionResolverImpl samConversionResolver;
|
||||
private final JavaSourceElementFactoryImpl javaSourceElementFactory;
|
||||
private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
|
||||
private final SingleModuleClassResolver singleModuleClassResolver;
|
||||
private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
|
||||
private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
|
||||
@@ -133,19 +132,20 @@ public class InjectorForReplWithJava {
|
||||
private final ExpressionTypingUtils expressionTypingUtils;
|
||||
private final ForLoopConventionsChecker forLoopConventionsChecker;
|
||||
private final LocalClassifierAnalyzer localClassifierAnalyzer;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final DescriptorResolver descriptorResolver;
|
||||
private final DelegatedPropertyResolver delegatedPropertyResolver;
|
||||
private final TypeResolver typeResolver;
|
||||
private final QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private final LazinessToken lazinessToken;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final PartialBodyResolveProvider partialBodyResolveProvider;
|
||||
private final CallCompleter callCompleter;
|
||||
private final CandidateResolver candidateResolver;
|
||||
private final TaskPrioritizer taskPrioritizer;
|
||||
private final JetImportsFactory jetImportsFactory;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final LazyDeclarationResolver lazyDeclarationResolver;
|
||||
private final DeclarationScopeProviderImpl declarationScopeProvider;
|
||||
private final ScriptBodyResolver scriptBodyResolver;
|
||||
private final BodyResolver bodyResolver;
|
||||
private final ControlFlowAnalyzer controlFlowAnalyzer;
|
||||
@@ -153,12 +153,8 @@ public class InjectorForReplWithJava {
|
||||
private final ModifiersChecker modifiersChecker;
|
||||
private final FunctionAnalyzerExtension functionAnalyzerExtension;
|
||||
private final DeclarationResolver declarationResolver;
|
||||
private final ImportsResolver importsResolver;
|
||||
private final OverloadResolver overloadResolver;
|
||||
private final OverrideResolver overrideResolver;
|
||||
private final TopDownAnalyzer topDownAnalyzer;
|
||||
private final TypeHierarchyResolver typeHierarchyResolver;
|
||||
private final ScriptHeaderResolver scriptHeaderResolver;
|
||||
private final VarianceChecker varianceChecker;
|
||||
private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
|
||||
private final GlobalJavaResolverContext globalJavaResolverContext;
|
||||
@@ -184,8 +180,10 @@ public class InjectorForReplWithJava {
|
||||
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
|
||||
this.declarationProviderFactory = declarationProviderFactory;
|
||||
this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace);
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.moduleContentScope = moduleContentScope;
|
||||
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
|
||||
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
|
||||
this.javaClassFinder = new JavaClassFinderImpl();
|
||||
this.virtualFileFinder = org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope);
|
||||
this.traceBasedErrorReporter = new TraceBasedErrorReporter();
|
||||
@@ -204,7 +202,6 @@ public class InjectorForReplWithJava {
|
||||
this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
|
||||
this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, virtualFileFinder, traceBasedErrorReporter);
|
||||
this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
|
||||
this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module);
|
||||
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
|
||||
this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
|
||||
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
|
||||
@@ -218,20 +215,21 @@ public class InjectorForReplWithJava {
|
||||
this.dynamicTypesSettings = new DynamicTypesSettings();
|
||||
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.descriptorResolver = new DescriptorResolver();
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
|
||||
this.lazinessToken = new LazinessToken();
|
||||
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings);
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
|
||||
this.candidateResolver = new CandidateResolver();
|
||||
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
|
||||
this.taskPrioritizer = new TaskPrioritizer(storageManager);
|
||||
this.jetImportsFactory = new JetImportsFactory();
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
|
||||
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
|
||||
this.scriptBodyResolver = new ScriptBodyResolver();
|
||||
this.bodyResolver = new BodyResolver();
|
||||
this.controlFlowAnalyzer = new ControlFlowAnalyzer();
|
||||
@@ -239,32 +237,37 @@ public class InjectorForReplWithJava {
|
||||
this.modifiersChecker = new ModifiersChecker(bindingTrace, kotlinJvmCheckerProvider);
|
||||
this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
|
||||
this.declarationResolver = new DeclarationResolver();
|
||||
this.importsResolver = new ImportsResolver();
|
||||
this.overloadResolver = new OverloadResolver();
|
||||
this.overrideResolver = new OverrideResolver();
|
||||
this.topDownAnalyzer = new TopDownAnalyzer();
|
||||
this.typeHierarchyResolver = new TypeHierarchyResolver();
|
||||
this.scriptHeaderResolver = new ScriptHeaderResolver();
|
||||
this.varianceChecker = new VarianceChecker(bindingTrace);
|
||||
|
||||
this.resolveSession.setAnnotationResolve(annotationResolver);
|
||||
this.resolveSession.setDescriptorResolver(descriptorResolver);
|
||||
this.resolveSession.setJetImportFactory(jetImportsFactory);
|
||||
this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
this.resolveSession.setScopeProvider(scopeProvider);
|
||||
this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
|
||||
this.resolveSession.setTypeResolver(typeResolver);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
|
||||
this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession);
|
||||
this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
|
||||
this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.lazyTopDownAnalyzer.setModuleDescriptor(module);
|
||||
this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
|
||||
this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
|
||||
this.lazyTopDownAnalyzer.setTrace(bindingTrace);
|
||||
this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
this.lazyTopDownAnalyzerForTopLevel.setKotlinCodeAnalyzer(resolveSession);
|
||||
this.lazyTopDownAnalyzerForTopLevel.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
|
||||
|
||||
javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
|
||||
javaClassFinder.setProject(project);
|
||||
javaClassFinder.setScope(moduleContentScope);
|
||||
@@ -328,8 +331,6 @@ public class InjectorForReplWithJava {
|
||||
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
|
||||
forLoopConventionsChecker.setProject(project);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
descriptorResolver.setAnnotationResolver(annotationResolver);
|
||||
descriptorResolver.setBuiltIns(kotlinBuiltIns);
|
||||
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
|
||||
@@ -341,11 +342,16 @@ public class InjectorForReplWithJava {
|
||||
delegatedPropertyResolver.setCallResolver(callResolver);
|
||||
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
|
||||
|
||||
jetImportsFactory.setProject(project);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
|
||||
|
||||
declarationScopeProvider.setFileScopeProvider(scopeProvider);
|
||||
|
||||
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
@@ -368,37 +374,12 @@ public class InjectorForReplWithJava {
|
||||
functionAnalyzerExtension.setTrace(bindingTrace);
|
||||
|
||||
declarationResolver.setAnnotationResolver(annotationResolver);
|
||||
declarationResolver.setDescriptorResolver(descriptorResolver);
|
||||
declarationResolver.setImportsResolver(importsResolver);
|
||||
declarationResolver.setTrace(bindingTrace);
|
||||
|
||||
importsResolver.setImportsFactory(jetImportsFactory);
|
||||
importsResolver.setModuleDescriptor(module);
|
||||
importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
importsResolver.setTrace(bindingTrace);
|
||||
|
||||
overloadResolver.setTrace(bindingTrace);
|
||||
|
||||
overrideResolver.setTrace(bindingTrace);
|
||||
|
||||
topDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
topDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
topDownAnalyzer.setModuleDescriptor(module);
|
||||
topDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
topDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
|
||||
topDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
|
||||
typeHierarchyResolver.setImportsResolver(importsResolver);
|
||||
typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
|
||||
typeHierarchyResolver.setTrace(bindingTrace);
|
||||
|
||||
scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
scriptHeaderResolver.setTrace(bindingTrace);
|
||||
|
||||
deserializedDescriptorResolver.setComponents(deserializationComponentsForJava);
|
||||
|
||||
javaClassFinder.initialize();
|
||||
@@ -419,6 +400,10 @@ public class InjectorForReplWithJava {
|
||||
return this.lazyTopDownAnalyzer;
|
||||
}
|
||||
|
||||
public LazyTopDownAnalyzerForTopLevel getLazyTopDownAnalyzerForTopLevel() {
|
||||
return this.lazyTopDownAnalyzerForTopLevel;
|
||||
}
|
||||
|
||||
public JavaDescriptorResolver getJavaDescriptorResolver() {
|
||||
return this.javaDescriptorResolver;
|
||||
}
|
||||
|
||||
@@ -25,8 +25,10 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
|
||||
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 com.intellij.psi.search.GlobalSearchScope;
|
||||
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
|
||||
import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
|
||||
import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava;
|
||||
import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder;
|
||||
@@ -39,7 +41,6 @@ import org.jetbrains.kotlin.load.java.components.PsiBasedExternalAnnotationResol
|
||||
import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
|
||||
import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl;
|
||||
import org.jetbrains.kotlin.load.java.components.JavaSourceElementFactoryImpl;
|
||||
import org.jetbrains.kotlin.resolve.MutablePackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
|
||||
import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
|
||||
import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
|
||||
@@ -54,33 +55,30 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings;
|
||||
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver;
|
||||
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver;
|
||||
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
|
||||
import org.jetbrains.kotlin.context.LazinessToken;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
|
||||
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
|
||||
import org.jetbrains.kotlin.psi.JetImportsFactory;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
|
||||
import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.BodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.DeclarationsChecker;
|
||||
import org.jetbrains.kotlin.resolve.ModifiersChecker;
|
||||
import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
|
||||
import org.jetbrains.kotlin.resolve.DeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.ImportsResolver;
|
||||
import org.jetbrains.kotlin.resolve.OverloadResolver;
|
||||
import org.jetbrains.kotlin.resolve.OverrideResolver;
|
||||
import org.jetbrains.kotlin.resolve.TopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.TypeHierarchyResolver;
|
||||
import org.jetbrains.kotlin.resolve.ScriptHeaderResolver;
|
||||
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
|
||||
import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext;
|
||||
@@ -103,8 +101,10 @@ public class InjectorForTopDownAnalyzerForJvm {
|
||||
private final PlatformToKotlinClassMap platformToKotlinClassMap;
|
||||
private final DeclarationProviderFactory declarationProviderFactory;
|
||||
private final ResolveSession resolveSession;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final GlobalSearchScope moduleContentScope;
|
||||
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
|
||||
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
|
||||
private final JavaDescriptorResolver javaDescriptorResolver;
|
||||
private final DeserializationComponentsForJava deserializationComponentsForJava;
|
||||
private final VirtualFileFinder virtualFileFinder;
|
||||
@@ -117,7 +117,6 @@ public class InjectorForTopDownAnalyzerForJvm {
|
||||
private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
|
||||
private final SamConversionResolverImpl samConversionResolver;
|
||||
private final JavaSourceElementFactoryImpl javaSourceElementFactory;
|
||||
private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
|
||||
private final SingleModuleClassResolver singleModuleClassResolver;
|
||||
private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
|
||||
private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
|
||||
@@ -132,33 +131,30 @@ public class InjectorForTopDownAnalyzerForJvm {
|
||||
private final ExpressionTypingUtils expressionTypingUtils;
|
||||
private final ForLoopConventionsChecker forLoopConventionsChecker;
|
||||
private final LocalClassifierAnalyzer localClassifierAnalyzer;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final DescriptorResolver descriptorResolver;
|
||||
private final DelegatedPropertyResolver delegatedPropertyResolver;
|
||||
private final TypeResolver typeResolver;
|
||||
private final QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private final LazinessToken lazinessToken;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final PartialBodyResolveProvider partialBodyResolveProvider;
|
||||
private final CallCompleter callCompleter;
|
||||
private final CandidateResolver candidateResolver;
|
||||
private final TaskPrioritizer taskPrioritizer;
|
||||
private final JetImportsFactory jetImportsFactory;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private final LazyDeclarationResolver lazyDeclarationResolver;
|
||||
private final DeclarationScopeProviderImpl declarationScopeProvider;
|
||||
private final ScriptBodyResolver scriptBodyResolver;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private final BodyResolver bodyResolver;
|
||||
private final ControlFlowAnalyzer controlFlowAnalyzer;
|
||||
private final DeclarationsChecker declarationsChecker;
|
||||
private final ModifiersChecker modifiersChecker;
|
||||
private final FunctionAnalyzerExtension functionAnalyzerExtension;
|
||||
private final DeclarationResolver declarationResolver;
|
||||
private final ImportsResolver importsResolver;
|
||||
private final OverloadResolver overloadResolver;
|
||||
private final OverrideResolver overrideResolver;
|
||||
private final TopDownAnalyzer topDownAnalyzer;
|
||||
private final TypeHierarchyResolver typeHierarchyResolver;
|
||||
private final ScriptHeaderResolver scriptHeaderResolver;
|
||||
private final VarianceChecker varianceChecker;
|
||||
private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
|
||||
private final GlobalJavaResolverContext globalJavaResolverContext;
|
||||
@@ -183,8 +179,10 @@ public class InjectorForTopDownAnalyzerForJvm {
|
||||
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
|
||||
this.declarationProviderFactory = declarationProviderFactory;
|
||||
this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace);
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.moduleContentScope = moduleContentScope;
|
||||
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
|
||||
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
|
||||
this.javaClassFinder = new JavaClassFinderImpl();
|
||||
this.virtualFileFinder = org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope);
|
||||
this.traceBasedErrorReporter = new TraceBasedErrorReporter();
|
||||
@@ -203,7 +201,6 @@ public class InjectorForTopDownAnalyzerForJvm {
|
||||
this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
|
||||
this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, virtualFileFinder, traceBasedErrorReporter);
|
||||
this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
|
||||
this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module);
|
||||
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
|
||||
this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
|
||||
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
|
||||
@@ -216,54 +213,60 @@ public class InjectorForTopDownAnalyzerForJvm {
|
||||
this.dynamicTypesSettings = new DynamicTypesSettings();
|
||||
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.descriptorResolver = new DescriptorResolver();
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
|
||||
this.lazinessToken = new LazinessToken();
|
||||
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings);
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
|
||||
this.candidateResolver = new CandidateResolver();
|
||||
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
|
||||
this.taskPrioritizer = new TaskPrioritizer(storageManager);
|
||||
this.jetImportsFactory = new JetImportsFactory();
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
|
||||
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
|
||||
this.scriptBodyResolver = new ScriptBodyResolver();
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
this.bodyResolver = new BodyResolver();
|
||||
this.controlFlowAnalyzer = new ControlFlowAnalyzer();
|
||||
this.declarationsChecker = new DeclarationsChecker();
|
||||
this.modifiersChecker = new ModifiersChecker(bindingTrace, kotlinJvmCheckerProvider);
|
||||
this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
|
||||
this.declarationResolver = new DeclarationResolver();
|
||||
this.importsResolver = new ImportsResolver();
|
||||
this.overloadResolver = new OverloadResolver();
|
||||
this.overrideResolver = new OverrideResolver();
|
||||
this.topDownAnalyzer = new TopDownAnalyzer();
|
||||
this.typeHierarchyResolver = new TypeHierarchyResolver();
|
||||
this.scriptHeaderResolver = new ScriptHeaderResolver();
|
||||
this.varianceChecker = new VarianceChecker(bindingTrace);
|
||||
|
||||
this.resolveSession.setAnnotationResolve(annotationResolver);
|
||||
this.resolveSession.setDescriptorResolver(descriptorResolver);
|
||||
this.resolveSession.setJetImportFactory(jetImportsFactory);
|
||||
this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
this.resolveSession.setScopeProvider(scopeProvider);
|
||||
this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
|
||||
this.resolveSession.setTypeResolver(typeResolver);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
|
||||
this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession);
|
||||
this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
|
||||
this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.lazyTopDownAnalyzer.setModuleDescriptor(module);
|
||||
this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
|
||||
this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
|
||||
this.lazyTopDownAnalyzer.setTrace(bindingTrace);
|
||||
this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
this.lazyTopDownAnalyzerForTopLevel.setKotlinCodeAnalyzer(resolveSession);
|
||||
this.lazyTopDownAnalyzerForTopLevel.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
|
||||
|
||||
javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
|
||||
javaClassFinder.setProject(project);
|
||||
javaClassFinder.setScope(moduleContentScope);
|
||||
@@ -327,8 +330,6 @@ public class InjectorForTopDownAnalyzerForJvm {
|
||||
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
|
||||
forLoopConventionsChecker.setProject(project);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
descriptorResolver.setAnnotationResolver(annotationResolver);
|
||||
descriptorResolver.setBuiltIns(kotlinBuiltIns);
|
||||
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
|
||||
@@ -340,11 +341,16 @@ public class InjectorForTopDownAnalyzerForJvm {
|
||||
delegatedPropertyResolver.setCallResolver(callResolver);
|
||||
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
|
||||
|
||||
jetImportsFactory.setProject(project);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
|
||||
|
||||
declarationScopeProvider.setFileScopeProvider(scopeProvider);
|
||||
|
||||
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
@@ -367,37 +373,12 @@ public class InjectorForTopDownAnalyzerForJvm {
|
||||
functionAnalyzerExtension.setTrace(bindingTrace);
|
||||
|
||||
declarationResolver.setAnnotationResolver(annotationResolver);
|
||||
declarationResolver.setDescriptorResolver(descriptorResolver);
|
||||
declarationResolver.setImportsResolver(importsResolver);
|
||||
declarationResolver.setTrace(bindingTrace);
|
||||
|
||||
importsResolver.setImportsFactory(jetImportsFactory);
|
||||
importsResolver.setModuleDescriptor(module);
|
||||
importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
importsResolver.setTrace(bindingTrace);
|
||||
|
||||
overloadResolver.setTrace(bindingTrace);
|
||||
|
||||
overrideResolver.setTrace(bindingTrace);
|
||||
|
||||
topDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
topDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
topDownAnalyzer.setModuleDescriptor(module);
|
||||
topDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
topDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
|
||||
topDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
|
||||
typeHierarchyResolver.setImportsResolver(importsResolver);
|
||||
typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
|
||||
typeHierarchyResolver.setTrace(bindingTrace);
|
||||
|
||||
scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
scriptHeaderResolver.setTrace(bindingTrace);
|
||||
|
||||
deserializedDescriptorResolver.setComponents(deserializationComponentsForJava);
|
||||
|
||||
javaClassFinder.initialize();
|
||||
@@ -418,6 +399,10 @@ public class InjectorForTopDownAnalyzerForJvm {
|
||||
return this.lazyTopDownAnalyzer;
|
||||
}
|
||||
|
||||
public LazyTopDownAnalyzerForTopLevel getLazyTopDownAnalyzerForTopLevel() {
|
||||
return this.lazyTopDownAnalyzerForTopLevel;
|
||||
}
|
||||
|
||||
public JavaDescriptorResolver getJavaDescriptorResolver() {
|
||||
return this.javaDescriptorResolver;
|
||||
}
|
||||
|
||||
@@ -146,7 +146,7 @@ public enum TopDownAnalyzerFacadeForJVM {
|
||||
}
|
||||
additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
|
||||
|
||||
injector.getLazyTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files, additionalProviders);
|
||||
injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, files, additionalProviders);
|
||||
return AnalysisResult.success(trace.getBindingContext(), module);
|
||||
}
|
||||
finally {
|
||||
|
||||
@@ -314,71 +314,6 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class
|
||||
getWritableScopeForInitializers().changeLockLevel(WritableScope.LockLevel.READING);
|
||||
}
|
||||
|
||||
private PackageLikeBuilder builder = null;
|
||||
|
||||
@NotNull
|
||||
public PackageLikeBuilder getBuilder() {
|
||||
if (builder == null) {
|
||||
builder = new PackageLikeBuilder() {
|
||||
@NotNull
|
||||
@Override
|
||||
public DeclarationDescriptor getOwnerForChildren() {
|
||||
return MutableClassDescriptor.this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
|
||||
getScopeForMemberLookupAsWritableScope().addClassifierDescriptor(classDescriptor);
|
||||
scopeForMemberResolution.addClassifierDescriptor(classDescriptor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) {
|
||||
getScopeForMemberLookupAsWritableScope().addFunctionDescriptor(functionDescriptor);
|
||||
functions.add(functionDescriptor);
|
||||
if (functionDescriptor.getKind().isReal()) {
|
||||
declaredCallableMembers.add(functionDescriptor);
|
||||
}
|
||||
allCallableMembers.add(functionDescriptor);
|
||||
scopeForMemberResolution.addFunctionDescriptor(functionDescriptor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
|
||||
if (getKind() == ClassKind.CLASS_OBJECT || isInner()) {
|
||||
return ClassObjectStatus.NOT_ALLOWED;
|
||||
}
|
||||
|
||||
if (MutableClassDescriptor.this.classObjectDescriptor != null) {
|
||||
return ClassObjectStatus.DUPLICATE;
|
||||
}
|
||||
|
||||
assert classObjectDescriptor.getKind() == ClassKind.CLASS_OBJECT;
|
||||
MutableClassDescriptor.this.classObjectDescriptor = classObjectDescriptor;
|
||||
|
||||
// Members of the class object are accessible from the class
|
||||
// The scope must be lazy, because classObjectDescriptor may not by fully built yet
|
||||
scopeForMemberResolution.importScope(new ClassObjectMixinScope(classObjectDescriptor));
|
||||
|
||||
return ClassObjectStatus.OK;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
|
||||
getScopeForMemberLookupAsWritableScope().addPropertyDescriptor(propertyDescriptor);
|
||||
properties.add(propertyDescriptor);
|
||||
if (propertyDescriptor.getKind().isReal()) {
|
||||
declaredCallableMembers.add(propertyDescriptor);
|
||||
}
|
||||
allCallableMembers.add(propertyDescriptor);
|
||||
scopeForMemberResolution.addPropertyDescriptor(propertyDescriptor);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
return builder;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return DeclarationDescriptorImpl.toString(this);
|
||||
|
||||
@@ -26,14 +26,12 @@ import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
|
||||
|
||||
public class MutablePackageFragmentDescriptor extends PackageFragmentDescriptorImpl {
|
||||
private final WritableScope scope;
|
||||
private final PackageLikeBuilder builder;
|
||||
|
||||
public MutablePackageFragmentDescriptor(@NotNull ModuleDescriptor module, @NotNull FqName fqName) {
|
||||
super(module, fqName);
|
||||
|
||||
scope = new WritableScopeImpl(JetScope.Empty.INSTANCE$, this, RedeclarationHandler.DO_NOTHING, "Members of " + fqName + " in " + module);
|
||||
scope.changeLockLevel(WritableScope.LockLevel.BOTH);
|
||||
builder = new ScopeBasedPackageLikeBuilder(this, scope);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@@ -41,9 +39,4 @@ public class MutablePackageFragmentDescriptor extends PackageFragmentDescriptorI
|
||||
public WritableScope getMemberScope() {
|
||||
return scope;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public PackageLikeBuilder getBuilder() {
|
||||
return builder;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.descriptors.impl;
|
||||
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
|
||||
|
||||
public interface PackageLikeBuilder {
|
||||
@NotNull
|
||||
DeclarationDescriptor getOwnerForChildren();
|
||||
|
||||
void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor);
|
||||
|
||||
void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor);
|
||||
|
||||
void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor);
|
||||
|
||||
enum ClassObjectStatus {
|
||||
OK,
|
||||
DUPLICATE,
|
||||
NOT_ALLOWED
|
||||
}
|
||||
|
||||
ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor);
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.descriptors.impl;
|
||||
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
|
||||
|
||||
public class PackageLikeBuilderDummy implements PackageLikeBuilder {
|
||||
@NotNull
|
||||
@Override
|
||||
public DeclarationDescriptor getOwnerForChildren() {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.descriptors.impl;
|
||||
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
|
||||
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
|
||||
|
||||
public class ScopeBasedPackageLikeBuilder implements PackageLikeBuilder {
|
||||
private final DeclarationDescriptor containingDeclaration;
|
||||
private final WritableScope scope;
|
||||
|
||||
ScopeBasedPackageLikeBuilder(
|
||||
@NotNull DeclarationDescriptor containingDeclaration,
|
||||
@NotNull WritableScope scope
|
||||
) {
|
||||
this.containingDeclaration = containingDeclaration;
|
||||
this.scope = scope;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public DeclarationDescriptor getOwnerForChildren() {
|
||||
return containingDeclaration;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
|
||||
scope.addClassifierDescriptor(classDescriptor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) {
|
||||
scope.addFunctionDescriptor(functionDescriptor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
|
||||
scope.addPropertyDescriptor(propertyDescriptor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
|
||||
throw new IllegalStateException("Must be guaranteed not to happen by the parser");
|
||||
}
|
||||
}
|
||||
@@ -36,14 +36,14 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings;
|
||||
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver;
|
||||
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver;
|
||||
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
|
||||
import org.jetbrains.kotlin.context.LazinessToken;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
|
||||
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
|
||||
@@ -79,14 +79,14 @@ public class InjectorForBodyResolve {
|
||||
private final ExpressionTypingUtils expressionTypingUtils;
|
||||
private final ForLoopConventionsChecker forLoopConventionsChecker;
|
||||
private final LocalClassifierAnalyzer localClassifierAnalyzer;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final DescriptorResolver descriptorResolver;
|
||||
private final DelegatedPropertyResolver delegatedPropertyResolver;
|
||||
private final TypeResolver typeResolver;
|
||||
private final QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
|
||||
private final LazinessToken lazinessToken;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final CallCompleter callCompleter;
|
||||
private final CandidateResolver candidateResolver;
|
||||
private final TaskPrioritizer taskPrioritizer;
|
||||
@@ -123,15 +123,15 @@ public class InjectorForBodyResolve {
|
||||
this.dynamicTypesSettings = new DynamicTypesSettings();
|
||||
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.descriptorResolver = new DescriptorResolver();
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
|
||||
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
|
||||
this.lazinessToken = new LazinessToken();
|
||||
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings);
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.candidateResolver = new CandidateResolver();
|
||||
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
|
||||
this.taskPrioritizer = new TaskPrioritizer(storageManager);
|
||||
@@ -193,8 +193,6 @@ public class InjectorForBodyResolve {
|
||||
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
|
||||
forLoopConventionsChecker.setProject(project);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
descriptorResolver.setAnnotationResolver(annotationResolver);
|
||||
descriptorResolver.setBuiltIns(kotlinBuiltIns);
|
||||
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
|
||||
@@ -206,6 +204,8 @@ public class InjectorForBodyResolve {
|
||||
delegatedPropertyResolver.setCallResolver(callResolver);
|
||||
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
|
||||
|
||||
controlFlowAnalyzer.setTrace(bindingTrace);
|
||||
|
||||
@@ -20,13 +20,17 @@ import com.intellij.openapi.project.Project;
|
||||
import org.jetbrains.kotlin.context.GlobalContext;
|
||||
import org.jetbrains.kotlin.storage.StorageManager;
|
||||
import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
|
||||
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.BindingTrace;
|
||||
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
|
||||
import org.jetbrains.kotlin.types.DynamicTypesSettings;
|
||||
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
|
||||
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
|
||||
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
|
||||
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.BodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.AnnotationResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallResolver;
|
||||
@@ -37,14 +41,14 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver;
|
||||
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver;
|
||||
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
|
||||
import org.jetbrains.kotlin.context.LazinessToken;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
|
||||
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
|
||||
@@ -55,14 +59,8 @@ import org.jetbrains.kotlin.resolve.ModifiersChecker;
|
||||
import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
|
||||
import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.DeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.ImportsResolver;
|
||||
import org.jetbrains.kotlin.psi.JetImportsFactory;
|
||||
import org.jetbrains.kotlin.resolve.OverloadResolver;
|
||||
import org.jetbrains.kotlin.resolve.OverrideResolver;
|
||||
import org.jetbrains.kotlin.resolve.TopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.MutablePackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.resolve.TypeHierarchyResolver;
|
||||
import org.jetbrains.kotlin.resolve.ScriptHeaderResolver;
|
||||
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import javax.annotation.PreDestroy;
|
||||
@@ -75,13 +73,17 @@ public class InjectorForLazyBodyResolve {
|
||||
private final GlobalContext globalContext;
|
||||
private final StorageManager storageManager;
|
||||
private final KotlinCodeAnalyzer analyzer;
|
||||
private final ModuleDescriptor moduleDescriptor;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final BindingTrace bindingTrace;
|
||||
private final AdditionalCheckerProvider additionalCheckerProvider;
|
||||
private final DynamicTypesSettings dynamicTypesSettings;
|
||||
private final ModuleDescriptor moduleDescriptor;
|
||||
private final KotlinBuiltIns kotlinBuiltIns;
|
||||
private final PlatformToKotlinClassMap platformToKotlinClassMap;
|
||||
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private final DeclarationScopeProviderImpl declarationScopeProvider;
|
||||
private final LazyDeclarationResolver lazyDeclarationResolver;
|
||||
private final BodyResolver bodyResolver;
|
||||
private final AnnotationResolver annotationResolver;
|
||||
private final CallResolver callResolver;
|
||||
@@ -92,14 +94,14 @@ public class InjectorForLazyBodyResolve {
|
||||
private final ExpressionTypingUtils expressionTypingUtils;
|
||||
private final ForLoopConventionsChecker forLoopConventionsChecker;
|
||||
private final LocalClassifierAnalyzer localClassifierAnalyzer;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final DescriptorResolver descriptorResolver;
|
||||
private final DelegatedPropertyResolver delegatedPropertyResolver;
|
||||
private final TypeResolver typeResolver;
|
||||
private final QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
|
||||
private final LazinessToken lazinessToken;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final PartialBodyResolveProvider partialBodyResolveProvider;
|
||||
private final CallCompleter callCompleter;
|
||||
private final CandidateResolver candidateResolver;
|
||||
@@ -110,14 +112,8 @@ public class InjectorForLazyBodyResolve {
|
||||
private final FunctionAnalyzerExtension functionAnalyzerExtension;
|
||||
private final ScriptBodyResolver scriptBodyResolver;
|
||||
private final DeclarationResolver declarationResolver;
|
||||
private final ImportsResolver importsResolver;
|
||||
private final JetImportsFactory jetImportsFactory;
|
||||
private final OverloadResolver overloadResolver;
|
||||
private final OverrideResolver overrideResolver;
|
||||
private final TopDownAnalyzer topDownAnalyzer;
|
||||
private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
|
||||
private final TypeHierarchyResolver typeHierarchyResolver;
|
||||
private final ScriptHeaderResolver scriptHeaderResolver;
|
||||
private final VarianceChecker varianceChecker;
|
||||
|
||||
public InjectorForLazyBodyResolve(
|
||||
@@ -132,13 +128,17 @@ public class InjectorForLazyBodyResolve {
|
||||
this.globalContext = globalContext;
|
||||
this.storageManager = globalContext.getStorageManager();
|
||||
this.analyzer = analyzer;
|
||||
this.moduleDescriptor = analyzer.getModuleDescriptor();
|
||||
this.scopeProvider = analyzer.getScopeProvider();
|
||||
this.bindingTrace = bindingTrace;
|
||||
this.additionalCheckerProvider = additionalCheckerProvider;
|
||||
this.dynamicTypesSettings = dynamicTypesSettings;
|
||||
this.moduleDescriptor = analyzer.getModuleDescriptor();
|
||||
this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
|
||||
this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
|
||||
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
|
||||
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
|
||||
this.bodyResolver = new BodyResolver();
|
||||
this.annotationResolver = new AnnotationResolver();
|
||||
this.callResolver = new CallResolver();
|
||||
@@ -148,15 +148,15 @@ public class InjectorForLazyBodyResolve {
|
||||
this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
|
||||
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.descriptorResolver = new DescriptorResolver();
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
|
||||
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
|
||||
this.lazinessToken = new LazinessToken();
|
||||
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings);
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
|
||||
this.candidateResolver = new CandidateResolver();
|
||||
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
|
||||
@@ -167,26 +167,30 @@ public class InjectorForLazyBodyResolve {
|
||||
this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
|
||||
this.scriptBodyResolver = new ScriptBodyResolver();
|
||||
this.declarationResolver = new DeclarationResolver();
|
||||
this.importsResolver = new ImportsResolver();
|
||||
this.jetImportsFactory = new JetImportsFactory();
|
||||
this.overloadResolver = new OverloadResolver();
|
||||
this.overrideResolver = new OverrideResolver();
|
||||
this.topDownAnalyzer = new TopDownAnalyzer();
|
||||
this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(moduleDescriptor);
|
||||
this.typeHierarchyResolver = new TypeHierarchyResolver();
|
||||
this.scriptHeaderResolver = new ScriptHeaderResolver();
|
||||
this.varianceChecker = new VarianceChecker(bindingTrace);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
|
||||
this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(analyzer);
|
||||
this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
|
||||
this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
|
||||
this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
|
||||
this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(analyzer);
|
||||
this.lazyTopDownAnalyzer.setTrace(bindingTrace);
|
||||
this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
declarationScopeProvider.setFileScopeProvider(scopeProvider);
|
||||
|
||||
lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
lazyDeclarationResolver.setTopLevelDescriptorProvider(analyzer);
|
||||
|
||||
bodyResolver.setAnnotationResolver(annotationResolver);
|
||||
bodyResolver.setCallResolver(callResolver);
|
||||
bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
|
||||
@@ -239,8 +243,6 @@ public class InjectorForLazyBodyResolve {
|
||||
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
|
||||
forLoopConventionsChecker.setProject(project);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
descriptorResolver.setAnnotationResolver(annotationResolver);
|
||||
descriptorResolver.setBuiltIns(kotlinBuiltIns);
|
||||
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
|
||||
@@ -252,6 +254,8 @@ public class InjectorForLazyBodyResolve {
|
||||
delegatedPropertyResolver.setCallResolver(callResolver);
|
||||
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
|
||||
|
||||
controlFlowAnalyzer.setTrace(bindingTrace);
|
||||
@@ -265,39 +269,12 @@ public class InjectorForLazyBodyResolve {
|
||||
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
declarationResolver.setAnnotationResolver(annotationResolver);
|
||||
declarationResolver.setDescriptorResolver(descriptorResolver);
|
||||
declarationResolver.setImportsResolver(importsResolver);
|
||||
declarationResolver.setTrace(bindingTrace);
|
||||
|
||||
importsResolver.setImportsFactory(jetImportsFactory);
|
||||
importsResolver.setModuleDescriptor(moduleDescriptor);
|
||||
importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
importsResolver.setTrace(bindingTrace);
|
||||
|
||||
jetImportsFactory.setProject(project);
|
||||
|
||||
overloadResolver.setTrace(bindingTrace);
|
||||
|
||||
overrideResolver.setTrace(bindingTrace);
|
||||
|
||||
topDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
topDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
topDownAnalyzer.setModuleDescriptor(moduleDescriptor);
|
||||
topDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
topDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
|
||||
topDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
|
||||
typeHierarchyResolver.setImportsResolver(importsResolver);
|
||||
typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
|
||||
typeHierarchyResolver.setTrace(bindingTrace);
|
||||
|
||||
scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
scriptHeaderResolver.setTrace(bindingTrace);
|
||||
|
||||
}
|
||||
|
||||
@PreDestroy
|
||||
|
||||
@@ -23,10 +23,14 @@ import org.jetbrains.kotlin.resolve.BindingTrace;
|
||||
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
|
||||
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
|
||||
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
|
||||
import org.jetbrains.kotlin.resolve.TopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.MutablePackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
|
||||
import org.jetbrains.kotlin.types.DynamicTypesSettings;
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorManager;
|
||||
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
|
||||
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.BodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.AnnotationResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallResolver;
|
||||
@@ -37,14 +41,14 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver;
|
||||
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver;
|
||||
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
|
||||
import org.jetbrains.kotlin.context.LazinessToken;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
|
||||
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
|
||||
@@ -55,31 +59,31 @@ import org.jetbrains.kotlin.resolve.ModifiersChecker;
|
||||
import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
|
||||
import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.DeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.ImportsResolver;
|
||||
import org.jetbrains.kotlin.psi.JetImportsFactory;
|
||||
import org.jetbrains.kotlin.resolve.OverloadResolver;
|
||||
import org.jetbrains.kotlin.resolve.OverrideResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeHierarchyResolver;
|
||||
import org.jetbrains.kotlin.resolve.ScriptHeaderResolver;
|
||||
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import javax.annotation.PreDestroy;
|
||||
|
||||
/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
|
||||
@SuppressWarnings("all")
|
||||
public class InjectorForTopDownAnalyzerBasic {
|
||||
public class InjectorForLazyLocalClassifierAnalyzer {
|
||||
|
||||
private final Project project;
|
||||
private final GlobalContext globalContext;
|
||||
private final StorageManager storageManager;
|
||||
private final BindingTrace bindingTrace;
|
||||
private final ModuleDescriptor moduleDescriptor;
|
||||
private final ModuleDescriptor module;
|
||||
private final KotlinBuiltIns kotlinBuiltIns;
|
||||
private final PlatformToKotlinClassMap platformToKotlinClassMap;
|
||||
private final TopDownAnalyzer topDownAnalyzer;
|
||||
private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
|
||||
private final AdditionalCheckerProvider additionalCheckerProvider;
|
||||
private final DynamicTypesSettings dynamicTypesSettings;
|
||||
private final LocalClassDescriptorManager localClassDescriptorManager;
|
||||
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
|
||||
private final NoTopLevelDescriptorProvider noTopLevelDescriptorProvider;
|
||||
private final NoFileScopeProvider noFileScopeProvider;
|
||||
private final DeclarationScopeProviderForLocalClassifierAnalyzer declarationScopeProviderForLocalClassifierAnalyzer;
|
||||
private final LocalLazyDeclarationResolver localLazyDeclarationResolver;
|
||||
private final BodyResolver bodyResolver;
|
||||
private final AnnotationResolver annotationResolver;
|
||||
private final CallResolver callResolver;
|
||||
@@ -90,14 +94,14 @@ public class InjectorForTopDownAnalyzerBasic {
|
||||
private final ExpressionTypingUtils expressionTypingUtils;
|
||||
private final ForLoopConventionsChecker forLoopConventionsChecker;
|
||||
private final LocalClassifierAnalyzer localClassifierAnalyzer;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final DescriptorResolver descriptorResolver;
|
||||
private final DelegatedPropertyResolver delegatedPropertyResolver;
|
||||
private final TypeResolver typeResolver;
|
||||
private final QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
|
||||
private final LazinessToken lazinessToken;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final PartialBodyResolveProvider partialBodyResolveProvider;
|
||||
private final CallCompleter callCompleter;
|
||||
private final CandidateResolver candidateResolver;
|
||||
@@ -108,33 +112,34 @@ public class InjectorForTopDownAnalyzerBasic {
|
||||
private final FunctionAnalyzerExtension functionAnalyzerExtension;
|
||||
private final ScriptBodyResolver scriptBodyResolver;
|
||||
private final DeclarationResolver declarationResolver;
|
||||
private final ImportsResolver importsResolver;
|
||||
private final JetImportsFactory jetImportsFactory;
|
||||
private final OverloadResolver overloadResolver;
|
||||
private final OverrideResolver overrideResolver;
|
||||
private final TypeHierarchyResolver typeHierarchyResolver;
|
||||
private final ScriptHeaderResolver scriptHeaderResolver;
|
||||
private final VarianceChecker varianceChecker;
|
||||
|
||||
public InjectorForTopDownAnalyzerBasic(
|
||||
public InjectorForLazyLocalClassifierAnalyzer(
|
||||
@NotNull Project project,
|
||||
@NotNull GlobalContext globalContext,
|
||||
@NotNull BindingTrace bindingTrace,
|
||||
@NotNull ModuleDescriptor moduleDescriptor,
|
||||
@NotNull ModuleDescriptor module,
|
||||
@NotNull AdditionalCheckerProvider additionalCheckerProvider,
|
||||
@NotNull DynamicTypesSettings dynamicTypesSettings
|
||||
@NotNull DynamicTypesSettings dynamicTypesSettings,
|
||||
@NotNull LocalClassDescriptorManager localClassDescriptorManager
|
||||
) {
|
||||
this.project = project;
|
||||
this.globalContext = globalContext;
|
||||
this.storageManager = globalContext.getStorageManager();
|
||||
this.bindingTrace = bindingTrace;
|
||||
this.moduleDescriptor = moduleDescriptor;
|
||||
this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
|
||||
this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
|
||||
this.topDownAnalyzer = new TopDownAnalyzer();
|
||||
this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
|
||||
this.module = module;
|
||||
this.kotlinBuiltIns = module.getBuiltIns();
|
||||
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
|
||||
this.additionalCheckerProvider = additionalCheckerProvider;
|
||||
this.dynamicTypesSettings = dynamicTypesSettings;
|
||||
this.localClassDescriptorManager = localClassDescriptorManager;
|
||||
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
|
||||
this.noTopLevelDescriptorProvider = NoTopLevelDescriptorProvider.INSTANCE$;
|
||||
this.noFileScopeProvider = NoFileScopeProvider.INSTANCE$;
|
||||
this.localLazyDeclarationResolver = new LocalLazyDeclarationResolver(globalContext, bindingTrace, localClassDescriptorManager);
|
||||
this.declarationScopeProviderForLocalClassifierAnalyzer = new DeclarationScopeProviderForLocalClassifierAnalyzer(localLazyDeclarationResolver, localClassDescriptorManager);
|
||||
this.bodyResolver = new BodyResolver();
|
||||
this.annotationResolver = new AnnotationResolver();
|
||||
this.callResolver = new CallResolver();
|
||||
@@ -144,15 +149,15 @@ public class InjectorForTopDownAnalyzerBasic {
|
||||
this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
|
||||
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.reflectionTypes = new ReflectionTypes(getModuleDescriptor());
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.descriptorResolver = new DescriptorResolver();
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
|
||||
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
|
||||
this.lazinessToken = new LazinessToken();
|
||||
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings);
|
||||
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings);
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
|
||||
this.candidateResolver = new CandidateResolver();
|
||||
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
|
||||
@@ -163,22 +168,26 @@ public class InjectorForTopDownAnalyzerBasic {
|
||||
this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
|
||||
this.scriptBodyResolver = new ScriptBodyResolver();
|
||||
this.declarationResolver = new DeclarationResolver();
|
||||
this.importsResolver = new ImportsResolver();
|
||||
this.jetImportsFactory = new JetImportsFactory();
|
||||
this.overloadResolver = new OverloadResolver();
|
||||
this.overrideResolver = new OverrideResolver();
|
||||
this.typeHierarchyResolver = new TypeHierarchyResolver();
|
||||
this.scriptHeaderResolver = new ScriptHeaderResolver();
|
||||
this.varianceChecker = new VarianceChecker(bindingTrace);
|
||||
|
||||
this.topDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor);
|
||||
this.topDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
this.topDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
|
||||
this.topDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer);
|
||||
this.lazyTopDownAnalyzer.setFileScopeProvider(noFileScopeProvider);
|
||||
this.lazyTopDownAnalyzer.setLazyDeclarationResolver(localLazyDeclarationResolver);
|
||||
this.lazyTopDownAnalyzer.setModuleDescriptor(module);
|
||||
this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
|
||||
this.lazyTopDownAnalyzer.setTrace(bindingTrace);
|
||||
this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
declarationScopeProviderForLocalClassifierAnalyzer.setFileScopeProvider(noFileScopeProvider);
|
||||
|
||||
localLazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer);
|
||||
localLazyDeclarationResolver.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
|
||||
|
||||
bodyResolver.setAnnotationResolver(annotationResolver);
|
||||
bodyResolver.setCallResolver(callResolver);
|
||||
@@ -232,8 +241,6 @@ public class InjectorForTopDownAnalyzerBasic {
|
||||
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
|
||||
forLoopConventionsChecker.setProject(project);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
descriptorResolver.setAnnotationResolver(annotationResolver);
|
||||
descriptorResolver.setBuiltIns(kotlinBuiltIns);
|
||||
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
|
||||
@@ -245,6 +252,8 @@ public class InjectorForTopDownAnalyzerBasic {
|
||||
delegatedPropertyResolver.setCallResolver(callResolver);
|
||||
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
|
||||
|
||||
controlFlowAnalyzer.setTrace(bindingTrace);
|
||||
@@ -258,42 +267,20 @@ public class InjectorForTopDownAnalyzerBasic {
|
||||
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
declarationResolver.setAnnotationResolver(annotationResolver);
|
||||
declarationResolver.setDescriptorResolver(descriptorResolver);
|
||||
declarationResolver.setImportsResolver(importsResolver);
|
||||
declarationResolver.setTrace(bindingTrace);
|
||||
|
||||
importsResolver.setImportsFactory(jetImportsFactory);
|
||||
importsResolver.setModuleDescriptor(moduleDescriptor);
|
||||
importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
importsResolver.setTrace(bindingTrace);
|
||||
|
||||
jetImportsFactory.setProject(project);
|
||||
|
||||
overloadResolver.setTrace(bindingTrace);
|
||||
|
||||
overrideResolver.setTrace(bindingTrace);
|
||||
|
||||
typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
|
||||
typeHierarchyResolver.setImportsResolver(importsResolver);
|
||||
typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
|
||||
typeHierarchyResolver.setTrace(bindingTrace);
|
||||
|
||||
scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
scriptHeaderResolver.setTrace(bindingTrace);
|
||||
|
||||
}
|
||||
|
||||
@PreDestroy
|
||||
public void destroy() {
|
||||
}
|
||||
|
||||
public ModuleDescriptor getModuleDescriptor() {
|
||||
return this.moduleDescriptor;
|
||||
}
|
||||
|
||||
public TopDownAnalyzer getTopDownAnalyzer() {
|
||||
return this.topDownAnalyzer;
|
||||
public LazyTopDownAnalyzer getLazyTopDownAnalyzer() {
|
||||
return this.lazyTopDownAnalyzer;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.resolve.BindingTrace;
|
||||
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
|
||||
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.AnnotationResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallResolver;
|
||||
@@ -37,21 +38,22 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver;
|
||||
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver;
|
||||
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
|
||||
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
|
||||
import org.jetbrains.kotlin.psi.JetImportsFactory;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
|
||||
import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import javax.annotation.PreDestroy;
|
||||
|
||||
@@ -70,6 +72,7 @@ public class InjectorForLazyResolve {
|
||||
private final AdditionalCheckerProvider additionalCheckerProvider;
|
||||
private final DynamicTypesSettings dynamicTypesSettings;
|
||||
private final ResolveSession resolveSession;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final LazyResolveToken lazyResolveToken;
|
||||
private final AnnotationResolver annotationResolver;
|
||||
private final CallResolver callResolver;
|
||||
@@ -80,21 +83,22 @@ public class InjectorForLazyResolve {
|
||||
private final ExpressionTypingUtils expressionTypingUtils;
|
||||
private final ForLoopConventionsChecker forLoopConventionsChecker;
|
||||
private final LocalClassifierAnalyzer localClassifierAnalyzer;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final DescriptorResolver descriptorResolver;
|
||||
private final DelegatedPropertyResolver delegatedPropertyResolver;
|
||||
private final TypeResolver typeResolver;
|
||||
private final QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final PartialBodyResolveProvider partialBodyResolveProvider;
|
||||
private final CallCompleter callCompleter;
|
||||
private final CandidateResolver candidateResolver;
|
||||
private final TaskPrioritizer taskPrioritizer;
|
||||
private final JetImportsFactory jetImportsFactory;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private final LazyDeclarationResolver lazyDeclarationResolver;
|
||||
private final DeclarationScopeProviderImpl declarationScopeProvider;
|
||||
private final ScriptBodyResolver scriptBodyResolver;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
|
||||
public InjectorForLazyResolve(
|
||||
@NotNull Project project,
|
||||
@@ -116,6 +120,7 @@ public class InjectorForLazyResolve {
|
||||
this.additionalCheckerProvider = additionalCheckerProvider;
|
||||
this.dynamicTypesSettings = dynamicTypesSettings;
|
||||
this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.lazyResolveToken = new LazyResolveToken();
|
||||
this.annotationResolver = new AnnotationResolver();
|
||||
this.callResolver = new CallResolver();
|
||||
@@ -125,31 +130,36 @@ public class InjectorForLazyResolve {
|
||||
this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
|
||||
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.descriptorResolver = new DescriptorResolver();
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
|
||||
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
|
||||
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
|
||||
this.candidateResolver = new CandidateResolver();
|
||||
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
|
||||
this.taskPrioritizer = new TaskPrioritizer(storageManager);
|
||||
this.jetImportsFactory = new JetImportsFactory();
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
|
||||
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
|
||||
this.scriptBodyResolver = new ScriptBodyResolver();
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
|
||||
this.resolveSession.setAnnotationResolve(annotationResolver);
|
||||
this.resolveSession.setDescriptorResolver(descriptorResolver);
|
||||
this.resolveSession.setJetImportFactory(jetImportsFactory);
|
||||
this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
this.resolveSession.setScopeProvider(scopeProvider);
|
||||
this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
|
||||
this.resolveSession.setTypeResolver(typeResolver);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
|
||||
annotationResolver.setCallResolver(callResolver);
|
||||
annotationResolver.setStorageManager(storageManager);
|
||||
annotationResolver.setTypeResolver(typeResolver);
|
||||
@@ -192,8 +202,6 @@ public class InjectorForLazyResolve {
|
||||
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
|
||||
forLoopConventionsChecker.setProject(project);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
descriptorResolver.setAnnotationResolver(annotationResolver);
|
||||
descriptorResolver.setBuiltIns(kotlinBuiltIns);
|
||||
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
|
||||
@@ -205,11 +213,16 @@ public class InjectorForLazyResolve {
|
||||
delegatedPropertyResolver.setCallResolver(callResolver);
|
||||
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
|
||||
|
||||
jetImportsFactory.setProject(project);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
|
||||
|
||||
declarationScopeProvider.setFileScopeProvider(scopeProvider);
|
||||
|
||||
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
|
||||
@@ -25,7 +25,9 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
|
||||
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.LazyTopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
|
||||
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider.DefaultProvider;
|
||||
import org.jetbrains.kotlin.resolve.AnnotationResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallResolver;
|
||||
@@ -37,35 +39,31 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings;
|
||||
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver;
|
||||
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver;
|
||||
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
|
||||
import org.jetbrains.kotlin.context.LazinessToken;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
|
||||
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
|
||||
import org.jetbrains.kotlin.psi.JetImportsFactory;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
|
||||
import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.BodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.DeclarationsChecker;
|
||||
import org.jetbrains.kotlin.resolve.ModifiersChecker;
|
||||
import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
|
||||
import org.jetbrains.kotlin.resolve.DeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.ImportsResolver;
|
||||
import org.jetbrains.kotlin.resolve.OverloadResolver;
|
||||
import org.jetbrains.kotlin.resolve.OverrideResolver;
|
||||
import org.jetbrains.kotlin.resolve.TopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.MutablePackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.resolve.TypeHierarchyResolver;
|
||||
import org.jetbrains.kotlin.resolve.ScriptHeaderResolver;
|
||||
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import javax.annotation.PreDestroy;
|
||||
@@ -83,7 +81,9 @@ public class InjectorForLazyTopDownAnalyzerBasic {
|
||||
private final PlatformToKotlinClassMap platformToKotlinClassMap;
|
||||
private final DeclarationProviderFactory declarationProviderFactory;
|
||||
private final ResolveSession resolveSession;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
|
||||
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
|
||||
private final DefaultProvider defaultProvider;
|
||||
private final AnnotationResolver annotationResolver;
|
||||
private final CallResolver callResolver;
|
||||
@@ -95,35 +95,31 @@ public class InjectorForLazyTopDownAnalyzerBasic {
|
||||
private final ExpressionTypingUtils expressionTypingUtils;
|
||||
private final ForLoopConventionsChecker forLoopConventionsChecker;
|
||||
private final LocalClassifierAnalyzer localClassifierAnalyzer;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final DescriptorResolver descriptorResolver;
|
||||
private final DelegatedPropertyResolver delegatedPropertyResolver;
|
||||
private final TypeResolver typeResolver;
|
||||
private final QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
|
||||
private final LazinessToken lazinessToken;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final PartialBodyResolveProvider partialBodyResolveProvider;
|
||||
private final CallCompleter callCompleter;
|
||||
private final CandidateResolver candidateResolver;
|
||||
private final TaskPrioritizer taskPrioritizer;
|
||||
private final JetImportsFactory jetImportsFactory;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private final LazyDeclarationResolver lazyDeclarationResolver;
|
||||
private final DeclarationScopeProviderImpl declarationScopeProvider;
|
||||
private final ScriptBodyResolver scriptBodyResolver;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private final BodyResolver bodyResolver;
|
||||
private final ControlFlowAnalyzer controlFlowAnalyzer;
|
||||
private final DeclarationsChecker declarationsChecker;
|
||||
private final ModifiersChecker modifiersChecker;
|
||||
private final FunctionAnalyzerExtension functionAnalyzerExtension;
|
||||
private final DeclarationResolver declarationResolver;
|
||||
private final ImportsResolver importsResolver;
|
||||
private final OverloadResolver overloadResolver;
|
||||
private final OverrideResolver overrideResolver;
|
||||
private final TopDownAnalyzer topDownAnalyzer;
|
||||
private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
|
||||
private final TypeHierarchyResolver typeHierarchyResolver;
|
||||
private final ScriptHeaderResolver scriptHeaderResolver;
|
||||
private final VarianceChecker varianceChecker;
|
||||
|
||||
public InjectorForLazyTopDownAnalyzerBasic(
|
||||
@@ -142,7 +138,9 @@ public class InjectorForLazyTopDownAnalyzerBasic {
|
||||
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
|
||||
this.declarationProviderFactory = declarationProviderFactory;
|
||||
this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace);
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
|
||||
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
|
||||
this.defaultProvider = DefaultProvider.INSTANCE$;
|
||||
this.annotationResolver = new AnnotationResolver();
|
||||
this.callResolver = new CallResolver();
|
||||
@@ -153,56 +151,61 @@ public class InjectorForLazyTopDownAnalyzerBasic {
|
||||
this.dynamicTypesSettings = new DynamicTypesSettings();
|
||||
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.descriptorResolver = new DescriptorResolver();
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
|
||||
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
|
||||
this.lazinessToken = new LazinessToken();
|
||||
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings);
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
|
||||
this.candidateResolver = new CandidateResolver();
|
||||
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
|
||||
this.taskPrioritizer = new TaskPrioritizer(storageManager);
|
||||
this.jetImportsFactory = new JetImportsFactory();
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
|
||||
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
|
||||
this.scriptBodyResolver = new ScriptBodyResolver();
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
this.bodyResolver = new BodyResolver();
|
||||
this.controlFlowAnalyzer = new ControlFlowAnalyzer();
|
||||
this.declarationsChecker = new DeclarationsChecker();
|
||||
this.modifiersChecker = new ModifiersChecker(bindingTrace, defaultProvider);
|
||||
this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
|
||||
this.declarationResolver = new DeclarationResolver();
|
||||
this.importsResolver = new ImportsResolver();
|
||||
this.overloadResolver = new OverloadResolver();
|
||||
this.overrideResolver = new OverrideResolver();
|
||||
this.topDownAnalyzer = new TopDownAnalyzer();
|
||||
this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module);
|
||||
this.typeHierarchyResolver = new TypeHierarchyResolver();
|
||||
this.scriptHeaderResolver = new ScriptHeaderResolver();
|
||||
this.varianceChecker = new VarianceChecker(bindingTrace);
|
||||
|
||||
this.resolveSession.setAnnotationResolve(annotationResolver);
|
||||
this.resolveSession.setDescriptorResolver(descriptorResolver);
|
||||
this.resolveSession.setJetImportFactory(jetImportsFactory);
|
||||
this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
this.resolveSession.setScopeProvider(scopeProvider);
|
||||
this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
|
||||
this.resolveSession.setTypeResolver(typeResolver);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
|
||||
this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession);
|
||||
this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
|
||||
this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.lazyTopDownAnalyzer.setModuleDescriptor(module);
|
||||
this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
|
||||
this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
|
||||
this.lazyTopDownAnalyzer.setTrace(bindingTrace);
|
||||
this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
this.lazyTopDownAnalyzerForTopLevel.setKotlinCodeAnalyzer(resolveSession);
|
||||
this.lazyTopDownAnalyzerForTopLevel.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
|
||||
|
||||
annotationResolver.setCallResolver(callResolver);
|
||||
annotationResolver.setStorageManager(storageManager);
|
||||
annotationResolver.setTypeResolver(typeResolver);
|
||||
@@ -245,8 +248,6 @@ public class InjectorForLazyTopDownAnalyzerBasic {
|
||||
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
|
||||
forLoopConventionsChecker.setProject(project);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
descriptorResolver.setAnnotationResolver(annotationResolver);
|
||||
descriptorResolver.setBuiltIns(kotlinBuiltIns);
|
||||
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
|
||||
@@ -258,11 +259,16 @@ public class InjectorForLazyTopDownAnalyzerBasic {
|
||||
delegatedPropertyResolver.setCallResolver(callResolver);
|
||||
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
|
||||
|
||||
jetImportsFactory.setProject(project);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
|
||||
|
||||
declarationScopeProvider.setFileScopeProvider(scopeProvider);
|
||||
|
||||
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
@@ -285,37 +291,12 @@ public class InjectorForLazyTopDownAnalyzerBasic {
|
||||
functionAnalyzerExtension.setTrace(bindingTrace);
|
||||
|
||||
declarationResolver.setAnnotationResolver(annotationResolver);
|
||||
declarationResolver.setDescriptorResolver(descriptorResolver);
|
||||
declarationResolver.setImportsResolver(importsResolver);
|
||||
declarationResolver.setTrace(bindingTrace);
|
||||
|
||||
importsResolver.setImportsFactory(jetImportsFactory);
|
||||
importsResolver.setModuleDescriptor(module);
|
||||
importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
importsResolver.setTrace(bindingTrace);
|
||||
|
||||
overloadResolver.setTrace(bindingTrace);
|
||||
|
||||
overrideResolver.setTrace(bindingTrace);
|
||||
|
||||
topDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
topDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
topDownAnalyzer.setModuleDescriptor(module);
|
||||
topDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
topDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
|
||||
topDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
|
||||
typeHierarchyResolver.setImportsResolver(importsResolver);
|
||||
typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
|
||||
typeHierarchyResolver.setTrace(bindingTrace);
|
||||
|
||||
scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
scriptHeaderResolver.setTrace(bindingTrace);
|
||||
|
||||
}
|
||||
|
||||
@PreDestroy
|
||||
@@ -330,4 +311,8 @@ public class InjectorForLazyTopDownAnalyzerBasic {
|
||||
return this.lazyTopDownAnalyzer;
|
||||
}
|
||||
|
||||
public LazyTopDownAnalyzerForTopLevel getLazyTopDownAnalyzerForTopLevel() {
|
||||
return this.lazyTopDownAnalyzerForTopLevel;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -109,7 +109,7 @@ public class InjectorForMacros {
|
||||
this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices());
|
||||
this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), getCallResolver(), kotlinBuiltIns);
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
|
||||
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
|
||||
this.argumentTypeResolver = new ArgumentTypeResolver();
|
||||
this.candidateResolver = new CandidateResolver();
|
||||
|
||||
@@ -46,23 +46,14 @@ import static org.jetbrains.kotlin.resolve.BindingContext.DEFERRED_TYPE;
|
||||
import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
|
||||
|
||||
public class BodyResolver {
|
||||
@NotNull
|
||||
private ScriptBodyResolver scriptBodyResolverResolver;
|
||||
@NotNull
|
||||
private ExpressionTypingServices expressionTypingServices;
|
||||
@NotNull
|
||||
private CallResolver callResolver;
|
||||
@NotNull
|
||||
private ObservableBindingTrace trace;
|
||||
@NotNull
|
||||
private ControlFlowAnalyzer controlFlowAnalyzer;
|
||||
@NotNull
|
||||
private DeclarationsChecker declarationsChecker;
|
||||
@NotNull
|
||||
private AnnotationResolver annotationResolver;
|
||||
@NotNull
|
||||
private DelegatedPropertyResolver delegatedPropertyResolver;
|
||||
@NotNull
|
||||
private FunctionAnalyzerExtension functionAnalyzerExtension;
|
||||
|
||||
@Inject
|
||||
|
||||
@@ -16,44 +16,40 @@
|
||||
|
||||
package org.jetbrains.kotlin.resolve;
|
||||
|
||||
import com.google.common.base.Function;
|
||||
import com.google.common.base.Predicate;
|
||||
import com.google.common.collect.*;
|
||||
import com.google.common.collect.HashMultimap;
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.common.collect.Multimap;
|
||||
import com.google.common.collect.Sets;
|
||||
import com.intellij.openapi.util.Pair;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.util.containers.ContainerUtil;
|
||||
import kotlin.Function1;
|
||||
import kotlin.KotlinPackage;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
|
||||
import org.jetbrains.kotlin.descriptors.*;
|
||||
import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.impl.PackageLikeBuilder;
|
||||
import org.jetbrains.kotlin.diagnostics.Errors;
|
||||
import org.jetbrains.kotlin.name.FqName;
|
||||
import org.jetbrains.kotlin.name.Name;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
import org.jetbrains.kotlin.renderer.DescriptorRenderer;
|
||||
import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
|
||||
import org.jetbrains.kotlin.psi.JetElement;
|
||||
import org.jetbrains.kotlin.psi.JetFile;
|
||||
import org.jetbrains.kotlin.psi.JetNamedDeclaration;
|
||||
import org.jetbrains.kotlin.psi.JetPackageDirective;
|
||||
import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.TopLevelDescriptorProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor;
|
||||
import org.jetbrains.kotlin.resolve.resolveUtil.ResolveUtilPackage;
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope;
|
||||
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
|
||||
import org.jetbrains.kotlin.utils.UtilsPackage;
|
||||
|
||||
import javax.inject.Inject;
|
||||
import java.util.*;
|
||||
import java.util.Collection;
|
||||
import java.util.HashSet;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import static org.jetbrains.kotlin.diagnostics.Errors.REDECLARATION;
|
||||
import static org.jetbrains.kotlin.resolve.ScriptHeaderResolver.resolveScriptDeclarations;
|
||||
|
||||
public class DeclarationResolver {
|
||||
private AnnotationResolver annotationResolver;
|
||||
private ImportsResolver importsResolver;
|
||||
private DescriptorResolver descriptorResolver;
|
||||
private BindingTrace trace;
|
||||
|
||||
|
||||
@@ -62,41 +58,13 @@ public class DeclarationResolver {
|
||||
this.annotationResolver = annotationResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setImportsResolver(@NotNull ImportsResolver importsResolver) {
|
||||
this.importsResolver = importsResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) {
|
||||
this.descriptorResolver = descriptorResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setTrace(@NotNull BindingTrace trace) {
|
||||
this.trace = trace;
|
||||
}
|
||||
|
||||
|
||||
public void process(@NotNull TopDownAnalysisContext c) {
|
||||
resolveAnnotationConstructors(c);
|
||||
resolveConstructorHeaders(c);
|
||||
resolveAnnotationStubsOnClassesAndConstructors(c);
|
||||
resolveFunctionAndPropertyHeaders(c);
|
||||
resolveDanglingAnnotationsInClasses(c);
|
||||
resolveAnnotationsOnFiles(c.getFileScopes());
|
||||
|
||||
// SCRIPT: Resolve script declarations
|
||||
resolveScriptDeclarations(c);
|
||||
|
||||
createFunctionsForDataClasses(c);
|
||||
importsResolver.processMembersImports(c);
|
||||
ResolveUtilPackage.checkTraitRequirements(c.getDeclaredClasses(), trace);
|
||||
checkRedeclarationsInPackages(c);
|
||||
checkRedeclarationsInInnerClassNames(c);
|
||||
}
|
||||
|
||||
public void resolveAnnotationsOnFiles(@NotNull TopDownAnalysisContext c, @NotNull final ScopeProvider scopeProvider) {
|
||||
public void resolveAnnotationsOnFiles(@NotNull TopDownAnalysisContext c, @NotNull final FileScopeProvider scopeProvider) {
|
||||
Map<JetFile, JetScope> file2scope = UtilsPackage.keysToMap(c.getFiles(), new Function1<JetFile, JetScope>() {
|
||||
@Override
|
||||
public JetScope invoke(JetFile file) {
|
||||
@@ -116,140 +84,6 @@ public class DeclarationResolver {
|
||||
}
|
||||
}
|
||||
|
||||
private void resolveAnnotationConstructors(@NotNull TopDownAnalysisContext c) {
|
||||
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
|
||||
JetClassOrObject classOrObject = entry.getKey();
|
||||
MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
|
||||
|
||||
if (classOrObject instanceof JetClass && DescriptorUtils.isAnnotationClass(classDescriptor)) {
|
||||
processPrimaryConstructor(c, classDescriptor, (JetClass) classOrObject);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void resolveConstructorHeaders(@NotNull TopDownAnalysisContext c) {
|
||||
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
|
||||
JetClassOrObject classOrObject = entry.getKey();
|
||||
MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
|
||||
|
||||
if (classOrObject instanceof JetClass && !DescriptorUtils.isAnnotationClass(classDescriptor)) {
|
||||
processPrimaryConstructor(c, classDescriptor, (JetClass) classOrObject);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void resolveAnnotationStubsOnClassesAndConstructors(@NotNull TopDownAnalysisContext c) {
|
||||
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
|
||||
JetModifierList modifierList = entry.getKey().getModifierList();
|
||||
if (modifierList != null) {
|
||||
MutableClassDescriptor descriptor = (MutableClassDescriptor) entry.getValue();
|
||||
descriptor.addAnnotations(annotationResolver.resolveAnnotationsWithoutArguments(
|
||||
descriptor.getScopeForClassHeaderResolution(), modifierList, trace));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void resolveFunctionAndPropertyHeaders(@NotNull TopDownAnalysisContext c) {
|
||||
for (Map.Entry<JetFile, WritableScope> entry : c.getFileScopes().entrySet()) {
|
||||
JetFile file = entry.getKey();
|
||||
WritableScope fileScope = entry.getValue();
|
||||
PackageLikeBuilder packageBuilder = c.getPackageFragments().get(file).getBuilder();
|
||||
|
||||
resolveFunctionAndPropertyHeaders(c, file.getDeclarations(), fileScope, fileScope, fileScope, packageBuilder);
|
||||
}
|
||||
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
|
||||
JetClassOrObject classOrObject = entry.getKey();
|
||||
MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
|
||||
|
||||
resolveFunctionAndPropertyHeaders(
|
||||
c,
|
||||
classOrObject.getDeclarations(), classDescriptor.getScopeForMemberDeclarationResolution(),
|
||||
classDescriptor.getScopeForInitializerResolution(), classDescriptor.getScopeForMemberDeclarationResolution(),
|
||||
classDescriptor.getBuilder());
|
||||
}
|
||||
|
||||
// TODO : Extensions
|
||||
}
|
||||
|
||||
private void resolveFunctionAndPropertyHeaders(
|
||||
@NotNull final TopDownAnalysisContext c,
|
||||
@NotNull List<JetDeclaration> declarations,
|
||||
@NotNull final JetScope scopeForFunctions,
|
||||
@NotNull final JetScope scopeForPropertyInitializers,
|
||||
@NotNull final JetScope scopeForPropertyAccessors,
|
||||
@NotNull final PackageLikeBuilder packageLike)
|
||||
{
|
||||
for (JetDeclaration declaration : declarations) {
|
||||
declaration.accept(new JetVisitorVoid() {
|
||||
@Override
|
||||
public void visitNamedFunction(@NotNull JetNamedFunction function) {
|
||||
SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(
|
||||
packageLike.getOwnerForChildren(),
|
||||
scopeForFunctions,
|
||||
function,
|
||||
trace,
|
||||
c.getOuterDataFlowInfo()
|
||||
);
|
||||
packageLike.addFunctionDescriptor(functionDescriptor);
|
||||
c.getFunctions().put(function, functionDescriptor);
|
||||
c.registerDeclaringScope(function, scopeForFunctions);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitProperty(@NotNull JetProperty property) {
|
||||
PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(
|
||||
packageLike.getOwnerForChildren(),
|
||||
scopeForPropertyInitializers,
|
||||
property,
|
||||
trace,
|
||||
c.getOuterDataFlowInfo()
|
||||
);
|
||||
packageLike.addPropertyDescriptor(propertyDescriptor);
|
||||
c.getProperties().put(property, propertyDescriptor);
|
||||
c.registerDeclaringScope(property, scopeForPropertyInitializers);
|
||||
JetPropertyAccessor getter = property.getGetter();
|
||||
if (getter != null) {
|
||||
c.registerDeclaringScope(getter, scopeForPropertyAccessors);
|
||||
}
|
||||
JetPropertyAccessor setter = property.getSetter();
|
||||
if (setter != null) {
|
||||
c.registerDeclaringScope(setter, scopeForPropertyAccessors);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private void resolveDanglingAnnotationsInClasses(TopDownAnalysisContext c) {
|
||||
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
|
||||
JetClassBody body = entry.getKey().getBody();
|
||||
if (body != null) {
|
||||
annotationResolver.resolveAnnotationsWithArguments(
|
||||
entry.getValue().getScopeForMemberDeclarationResolution(),
|
||||
body.getDanglingAnnotations(),
|
||||
trace
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void createFunctionsForDataClasses(@NotNull TopDownAnalysisContext c) {
|
||||
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
|
||||
JetClassOrObject klass = entry.getKey();
|
||||
MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
|
||||
|
||||
if (klass instanceof JetClass && KotlinBuiltIns.isData(classDescriptor)) {
|
||||
List<ValueParameterDescriptor> parameters =
|
||||
klass.hasPrimaryConstructor() ?
|
||||
getConstructorOfDataClass(classDescriptor).getValueParameters() :
|
||||
Collections.<ValueParameterDescriptor>emptyList();
|
||||
|
||||
createComponentFunctions(classDescriptor, parameters);
|
||||
createCopyFunction(classDescriptor, parameters);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static ConstructorDescriptor getConstructorOfDataClass(@NotNull ClassDescriptor classDescriptor) {
|
||||
Collection<ConstructorDescriptor> constructors = classDescriptor.getConstructors();
|
||||
@@ -257,124 +91,6 @@ public class DeclarationResolver {
|
||||
return constructors.iterator().next();
|
||||
}
|
||||
|
||||
private void createComponentFunctions(@NotNull MutableClassDescriptor classDescriptor, List<ValueParameterDescriptor> parameters) {
|
||||
int parameterIndex = 0;
|
||||
for (ValueParameterDescriptor parameter : parameters) {
|
||||
if (!parameter.getType().isError()) {
|
||||
PropertyDescriptor property = trace.get(BindingContext.VALUE_PARAMETER_AS_PROPERTY, parameter);
|
||||
if (property != null) {
|
||||
++parameterIndex;
|
||||
|
||||
SimpleFunctionDescriptor functionDescriptor =
|
||||
DescriptorResolver.createComponentFunctionDescriptor(parameterIndex, property, parameter, classDescriptor, trace);
|
||||
|
||||
classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void createCopyFunction(@NotNull MutableClassDescriptor classDescriptor, List<ValueParameterDescriptor> parameters) {
|
||||
SimpleFunctionDescriptor functionDescriptor = DescriptorResolver.createCopyFunctionDescriptor(
|
||||
parameters, classDescriptor, trace);
|
||||
|
||||
classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
|
||||
}
|
||||
|
||||
private void processPrimaryConstructor(
|
||||
@NotNull TopDownAnalysisContext c,
|
||||
@NotNull MutableClassDescriptor classDescriptor,
|
||||
@NotNull JetClass klass
|
||||
) {
|
||||
// TODO : not all the parameters are real properties
|
||||
JetScope memberScope = classDescriptor.getScopeForClassHeaderResolution();
|
||||
ConstructorDescriptor constructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass, trace);
|
||||
if (constructorDescriptor != null) {
|
||||
List<ValueParameterDescriptor> valueParameterDescriptors = constructorDescriptor.getValueParameters();
|
||||
List<JetParameter> primaryConstructorParameters = klass.getPrimaryConstructorParameters();
|
||||
assert valueParameterDescriptors.size() == primaryConstructorParameters.size();
|
||||
List<ValueParameterDescriptor> notProperties = new ArrayList<ValueParameterDescriptor>();
|
||||
for (ValueParameterDescriptor valueParameterDescriptor : valueParameterDescriptors) {
|
||||
JetParameter parameter = primaryConstructorParameters.get(valueParameterDescriptor.getIndex());
|
||||
if (parameter.hasValOrVarNode()) {
|
||||
PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePrimaryConstructorParameterToAProperty(
|
||||
classDescriptor,
|
||||
valueParameterDescriptor,
|
||||
memberScope,
|
||||
parameter, trace
|
||||
);
|
||||
classDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
|
||||
c.getPrimaryConstructorParameterProperties().put(parameter, propertyDescriptor);
|
||||
}
|
||||
else {
|
||||
notProperties.add(valueParameterDescriptor);
|
||||
}
|
||||
}
|
||||
|
||||
if (classDescriptor.getKind() != ClassKind.TRAIT) {
|
||||
classDescriptor.setPrimaryConstructor(constructorDescriptor);
|
||||
classDescriptor.addConstructorParametersToInitializersScope(notProperties);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void checkRedeclarationsInPackages(@NotNull TopDownAnalysisContext c) {
|
||||
for (MutablePackageFragmentDescriptor packageFragment : Sets.newHashSet(c.getPackageFragments().values())) {
|
||||
PackageViewDescriptor packageView = packageFragment.getContainingDeclaration().getPackage(packageFragment.getFqName());
|
||||
JetScope packageViewScope = packageView.getMemberScope();
|
||||
Multimap<Name, DeclarationDescriptor> simpleNameDescriptors = packageFragment.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName();
|
||||
for (Name name : simpleNameDescriptors.keySet()) {
|
||||
// Keep only properties with no receiver
|
||||
Collection<DeclarationDescriptor> descriptors = Collections2.filter(simpleNameDescriptors.get(name), new Predicate<DeclarationDescriptor>() {
|
||||
@Override
|
||||
public boolean apply(@Nullable DeclarationDescriptor descriptor) {
|
||||
if (descriptor instanceof PropertyDescriptor) {
|
||||
PropertyDescriptor propertyDescriptor = (PropertyDescriptor)descriptor;
|
||||
return propertyDescriptor.getExtensionReceiverParameter() == null;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
});
|
||||
ContainerUtil.addIfNotNull(descriptors, packageViewScope.getPackage(name));
|
||||
|
||||
if (descriptors.size() > 1) {
|
||||
for (DeclarationDescriptor declarationDescriptor : descriptors) {
|
||||
for (PsiElement declaration : getDeclarationsByDescriptor(declarationDescriptor)) {
|
||||
assert declaration != null : "Null declaration for descriptor: " + declarationDescriptor + " " +
|
||||
(declarationDescriptor != null ? DescriptorRenderer.FQ_NAMES_IN_TYPES.render(declarationDescriptor) : "");
|
||||
trace.report(REDECLARATION.on(declaration, declarationDescriptor.getName().asString()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private Collection<PsiElement> getDeclarationsByDescriptor(@NotNull DeclarationDescriptor declarationDescriptor) {
|
||||
Collection<PsiElement> declarations;
|
||||
if (declarationDescriptor instanceof PackageViewDescriptor) {
|
||||
final PackageViewDescriptor aPackage = (PackageViewDescriptor)declarationDescriptor;
|
||||
Collection<JetFile> files = trace.get(BindingContext.PACKAGE_TO_FILES, aPackage.getFqName());
|
||||
|
||||
if (files == null) {
|
||||
return Collections.emptyList(); // package can be defined out of Kotlin sources, e. g. in library or Java code
|
||||
}
|
||||
|
||||
declarations = Collections2.transform(files, new Function<JetFile, PsiElement>() {
|
||||
@Override
|
||||
public PsiElement apply(@Nullable JetFile file) {
|
||||
assert file != null : "File is null for aPackage " + aPackage;
|
||||
return file.getPackageDirective().getNameIdentifier();
|
||||
}
|
||||
});
|
||||
}
|
||||
else {
|
||||
declarations = Collections.singletonList(DescriptorToSourceUtils.descriptorToDeclaration(declarationDescriptor));
|
||||
}
|
||||
return declarations;
|
||||
}
|
||||
|
||||
public void checkRedeclarationsInInnerClassNames(@NotNull TopDownAnalysisContext c) {
|
||||
for (ClassDescriptorWithResolutionScopes classDescriptor : c.getDeclaredClasses().values()) {
|
||||
if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) {
|
||||
@@ -435,14 +151,17 @@ public class DeclarationResolver {
|
||||
}
|
||||
}
|
||||
|
||||
public void checkRedeclarationsInPackages(@NotNull KotlinCodeAnalyzer resolveSession, @NotNull Multimap<FqName, JetElement> topLevelFqNames) {
|
||||
public void checkRedeclarationsInPackages(
|
||||
@NotNull TopLevelDescriptorProvider topLevelDescriptorProvider,
|
||||
@NotNull Multimap<FqName, JetElement> topLevelFqNames
|
||||
) {
|
||||
for (Map.Entry<FqName, Collection<JetElement>> entry : topLevelFqNames.asMap().entrySet()) {
|
||||
FqName fqName = entry.getKey();
|
||||
Collection<JetElement> declarationsOrPackageDirectives = entry.getValue();
|
||||
|
||||
if (fqName.isRoot()) continue;
|
||||
|
||||
Set<DeclarationDescriptor> descriptors = getTopLevelDescriptorsByFqName(resolveSession, fqName);
|
||||
Set<DeclarationDescriptor> descriptors = getTopLevelDescriptorsByFqName(topLevelDescriptorProvider, fqName);
|
||||
|
||||
if (descriptors.size() > 1) {
|
||||
for (JetElement declarationOrPackageDirective : declarationsOrPackageDirectives) {
|
||||
@@ -456,12 +175,15 @@ public class DeclarationResolver {
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static Set<DeclarationDescriptor> getTopLevelDescriptorsByFqName(@NotNull KotlinCodeAnalyzer resolveSession, @NotNull FqName fqName) {
|
||||
private static Set<DeclarationDescriptor> getTopLevelDescriptorsByFqName(
|
||||
@NotNull TopLevelDescriptorProvider topLevelDescriptorProvider,
|
||||
@NotNull FqName fqName
|
||||
) {
|
||||
FqName parentFqName = fqName.parent();
|
||||
|
||||
Set<DeclarationDescriptor> descriptors = new HashSet<DeclarationDescriptor>();
|
||||
|
||||
LazyPackageDescriptor parentFragment = resolveSession.getPackageFragment(parentFqName);
|
||||
LazyPackageDescriptor parentFragment = topLevelDescriptorProvider.getPackageFragment(parentFqName);
|
||||
if (parentFragment != null) {
|
||||
// Filter out extension properties
|
||||
descriptors.addAll(
|
||||
@@ -477,9 +199,9 @@ public class DeclarationResolver {
|
||||
);
|
||||
}
|
||||
|
||||
ContainerUtil.addIfNotNull(descriptors, resolveSession.getPackageFragment(fqName));
|
||||
ContainerUtil.addIfNotNull(descriptors, topLevelDescriptorProvider.getPackageFragment(fqName));
|
||||
|
||||
descriptors.addAll(resolveSession.getTopLevelClassDescriptors(fqName));
|
||||
descriptors.addAll(topLevelDescriptorProvider.getTopLevelClassDescriptors(fqName));
|
||||
return descriptors;
|
||||
}
|
||||
|
||||
|
||||
@@ -17,12 +17,10 @@
|
||||
package org.jetbrains.kotlin.resolve;
|
||||
|
||||
import com.google.common.base.Predicate;
|
||||
import com.google.common.base.Predicates;
|
||||
import com.google.common.collect.Collections2;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.jetbrains.kotlin.descriptors.*;
|
||||
import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor;
|
||||
import org.jetbrains.kotlin.psi.JetClassOrObject;
|
||||
import org.jetbrains.kotlin.psi.JetDelegationSpecifier;
|
||||
import org.jetbrains.kotlin.psi.JetDelegatorByExpressionSpecifier;
|
||||
@@ -30,7 +28,10 @@ import org.jetbrains.kotlin.psi.JetTypeReference;
|
||||
import org.jetbrains.kotlin.types.JetType;
|
||||
import org.jetbrains.kotlin.types.TypeUtils;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
|
||||
import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DELEGATION;
|
||||
import static org.jetbrains.kotlin.diagnostics.Errors.MANY_IMPL_MEMBER_NOT_IMPLEMENTED;
|
||||
@@ -38,43 +39,6 @@ import static org.jetbrains.kotlin.resolve.OverridingUtil.OverrideCompatibilityI
|
||||
|
||||
public final class DelegationResolver<T extends CallableMemberDescriptor> {
|
||||
|
||||
public static void generateDelegatesInAClass(
|
||||
@NotNull MutableClassDescriptor classDescriptor,
|
||||
@NotNull final BindingTrace trace,
|
||||
@NotNull JetClassOrObject jetClassOrObject
|
||||
) {
|
||||
TypeResolver eagerTypeResolver = new TypeResolver() {
|
||||
@Nullable
|
||||
@Override
|
||||
public JetType resolve(@NotNull JetTypeReference reference) {
|
||||
return trace.get(BindingContext.TYPE, reference);
|
||||
}
|
||||
};
|
||||
MemberExtractor<CallableMemberDescriptor> eagerExtractor = new MemberExtractor<CallableMemberDescriptor>() {
|
||||
@NotNull
|
||||
@Override
|
||||
public Collection<CallableMemberDescriptor> getMembersByType(@NotNull JetType type) {
|
||||
//noinspection unchecked
|
||||
return (Collection) Collections2.filter(type.getMemberScope().getAllDescriptors(),
|
||||
Predicates.instanceOf(CallableMemberDescriptor.class));
|
||||
}
|
||||
};
|
||||
Set<CallableMemberDescriptor> existingMembers = classDescriptor.getAllCallableMembers();
|
||||
Collection<CallableMemberDescriptor> delegatedMembers =
|
||||
generateDelegatedMembers(jetClassOrObject, classDescriptor, existingMembers, trace, eagerExtractor, eagerTypeResolver);
|
||||
for (CallableMemberDescriptor descriptor : delegatedMembers) {
|
||||
if (descriptor instanceof PropertyDescriptor) {
|
||||
PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
|
||||
classDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
|
||||
}
|
||||
else if (descriptor instanceof SimpleFunctionDescriptor) {
|
||||
SimpleFunctionDescriptor functionDescriptor = (SimpleFunctionDescriptor) descriptor;
|
||||
classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@NotNull
|
||||
public static <T extends CallableMemberDescriptor> Collection<T> generateDelegatedMembers(
|
||||
@NotNull JetClassOrObject classOrObject,
|
||||
|
||||
@@ -1,197 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.common.collect.Maps;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.jetbrains.kotlin.descriptors.*;
|
||||
import org.jetbrains.kotlin.descriptors.impl.ScriptDescriptorImpl;
|
||||
import org.jetbrains.kotlin.name.Name;
|
||||
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope;
|
||||
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
|
||||
|
||||
import javax.inject.Inject;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.jetbrains.kotlin.diagnostics.Errors.*;
|
||||
import static org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode;
|
||||
|
||||
public class ImportsResolver {
|
||||
private ModuleDescriptor moduleDescriptor;
|
||||
private QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private BindingTrace trace;
|
||||
private JetImportsFactory importsFactory;
|
||||
|
||||
@Inject
|
||||
public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) {
|
||||
this.moduleDescriptor = moduleDescriptor;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setTrace(@NotNull BindingTrace trace) {
|
||||
this.trace = trace;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setQualifiedExpressionResolver(@NotNull QualifiedExpressionResolver qualifiedExpressionResolver) {
|
||||
this.qualifiedExpressionResolver = qualifiedExpressionResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setImportsFactory(@NotNull JetImportsFactory importsFactory) {
|
||||
this.importsFactory = importsFactory;
|
||||
}
|
||||
|
||||
public void processTypeImports(@NotNull TopDownAnalysisContext c) {
|
||||
processImports(c, LookupMode.ONLY_CLASSES_AND_PACKAGES);
|
||||
}
|
||||
|
||||
public void processMembersImports(@NotNull TopDownAnalysisContext c) {
|
||||
processImports(c, LookupMode.EVERYTHING);
|
||||
}
|
||||
|
||||
private void processImports(@NotNull TopDownAnalysisContext c, @NotNull LookupMode lookupMode) {
|
||||
for (JetFile file : c.getFiles()) {
|
||||
if (file.isScript()) continue;
|
||||
WritableScope fileScope = c.getFileScopes().get(file);
|
||||
processImportsInFile(lookupMode, fileScope, Lists.newArrayList(file.getImportDirectives()), file.getPackageFqName().isRoot());
|
||||
}
|
||||
// SCRIPT: process script import directives
|
||||
for (JetScript script : c.getScripts().keySet()) {
|
||||
WritableScope scriptScope = ((ScriptDescriptorImpl) c.getScripts().get(script)).getScopeForBodyResolution();
|
||||
processImportsInFile(lookupMode, scriptScope, script.getContainingJetFile().getImportDirectives(), true);
|
||||
}
|
||||
}
|
||||
|
||||
private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List<JetImportDirective> directives, boolean inRootPackage) {
|
||||
processImportsInFile(lookupMode, scope, directives, moduleDescriptor, trace, qualifiedExpressionResolver, importsFactory, inRootPackage);
|
||||
}
|
||||
|
||||
private static void processImportsInFile(
|
||||
LookupMode lookupMode,
|
||||
@NotNull WritableScope fileScope,
|
||||
@NotNull List<JetImportDirective> importDirectives,
|
||||
@NotNull ModuleDescriptor module,
|
||||
@NotNull BindingTrace trace,
|
||||
@NotNull QualifiedExpressionResolver qualifiedExpressionResolver,
|
||||
@NotNull JetImportsFactory importsFactory,
|
||||
boolean inRootPackage
|
||||
) {
|
||||
@NotNull JetScope rootScope = JetModuleUtil.getSubpackagesOfRootScope(module);
|
||||
|
||||
Importer importer = new Importer();
|
||||
if (lookupMode == LookupMode.EVERYTHING) {
|
||||
fileScope.clearImports();
|
||||
}
|
||||
|
||||
for (ImportPath defaultImportPath : module.getDefaultImports()) {
|
||||
TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(
|
||||
trace, "transient trace to resolve default imports"); //not to trace errors of default imports
|
||||
|
||||
JetImportDirective defaultImportDirective = importsFactory.createImportDirective(defaultImportPath);
|
||||
qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, fileScope, importer,
|
||||
temporaryTrace, lookupMode);
|
||||
}
|
||||
|
||||
Map<JetImportDirective, Collection<? extends DeclarationDescriptor>> resolvedDirectives = Maps.newHashMap();
|
||||
|
||||
JetScope rootScopeForFile = JetModuleUtil.getImportsResolutionScope(module, inRootPackage);
|
||||
|
||||
for (JetImportDirective importDirective : importDirectives) {
|
||||
Collection<? extends DeclarationDescriptor> descriptors =
|
||||
qualifiedExpressionResolver.processImportReference(importDirective, rootScopeForFile, fileScope, importer,
|
||||
trace, lookupMode);
|
||||
if (!descriptors.isEmpty()) {
|
||||
resolvedDirectives.put(importDirective, descriptors);
|
||||
}
|
||||
|
||||
if (lookupMode != LookupMode.ONLY_CLASSES_AND_PACKAGES) {
|
||||
checkPlatformTypesMappedToKotlin(module, trace, importDirective, descriptors);
|
||||
}
|
||||
}
|
||||
importer.doImport(fileScope);
|
||||
|
||||
if (lookupMode == LookupMode.EVERYTHING) {
|
||||
for (JetImportDirective importDirective : importDirectives) {
|
||||
reportConflictingImport(importDirective, fileScope, resolvedDirectives.get(importDirective), trace);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void checkPlatformTypesMappedToKotlin(
|
||||
@NotNull ModuleDescriptor module,
|
||||
@NotNull BindingTrace trace,
|
||||
@NotNull JetImportDirective importDirective,
|
||||
@NotNull Collection<? extends DeclarationDescriptor> descriptors
|
||||
) {
|
||||
JetExpression importedReference = importDirective.getImportedReference();
|
||||
if (importedReference != null) {
|
||||
for (DeclarationDescriptor descriptor : descriptors) {
|
||||
reportPlatformClassMappedToKotlin(module, trace, importedReference, descriptor);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void reportPlatformClassMappedToKotlin(
|
||||
@NotNull ModuleDescriptor module,
|
||||
@NotNull BindingTrace trace,
|
||||
@NotNull JetElement element,
|
||||
@NotNull DeclarationDescriptor descriptor
|
||||
) {
|
||||
if (!(descriptor instanceof ClassDescriptor)) return;
|
||||
|
||||
PlatformToKotlinClassMap platformToKotlinMap = module.getPlatformToKotlinClassMap();
|
||||
Collection<ClassDescriptor> kotlinAnalogsForClass = platformToKotlinMap.mapPlatformClass((ClassDescriptor) descriptor);
|
||||
if (!kotlinAnalogsForClass.isEmpty()) {
|
||||
trace.report(PLATFORM_CLASS_MAPPED_TO_KOTLIN.on(element, kotlinAnalogsForClass));
|
||||
}
|
||||
}
|
||||
|
||||
public static void reportConflictingImport(
|
||||
@NotNull JetImportDirective importDirective,
|
||||
@NotNull JetScope fileScope,
|
||||
@Nullable Collection<? extends DeclarationDescriptor> resolvedTo,
|
||||
@NotNull BindingTrace trace
|
||||
) {
|
||||
|
||||
JetExpression importedReference = importDirective.getImportedReference();
|
||||
if (importedReference == null || resolvedTo == null) return;
|
||||
|
||||
Name aliasName = JetPsiUtil.getAliasName(importDirective);
|
||||
if (aliasName == null) return;
|
||||
|
||||
if (resolvedTo.size() != 1) return;
|
||||
|
||||
DeclarationDescriptor target = resolvedTo.iterator().next();
|
||||
if (target instanceof ClassDescriptor) {
|
||||
if (fileScope.getClassifier(aliasName) == null) {
|
||||
trace.report(CONFLICTING_IMPORT.on(importedReference, aliasName.asString()));
|
||||
}
|
||||
}
|
||||
else if (target instanceof PackageViewDescriptor) {
|
||||
if (fileScope.getPackage(aliasName) == null) {
|
||||
trace.report(CONFLICTING_IMPORT.on(importedReference, aliasName.asString()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -20,23 +20,19 @@ import com.google.common.collect.HashMultimap;
|
||||
import com.google.common.collect.Multimap;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.util.PsiTreeUtil;
|
||||
import kotlin.KotlinPackage;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.jetbrains.kotlin.descriptors.*;
|
||||
import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
|
||||
import org.jetbrains.kotlin.name.FqName;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyFileScope;
|
||||
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
|
||||
import org.jetbrains.kotlin.resolve.lazy.*;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor;
|
||||
import org.jetbrains.kotlin.resolve.resolveUtil.ResolveUtilPackage;
|
||||
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
|
||||
|
||||
import javax.inject.Inject;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
|
||||
@@ -56,15 +52,34 @@ public class LazyTopDownAnalyzer {
|
||||
|
||||
private ModuleDescriptor moduleDescriptor;
|
||||
|
||||
private KotlinCodeAnalyzer resolveSession;
|
||||
private LazyDeclarationResolver lazyDeclarationResolver;
|
||||
|
||||
private BodyResolver bodyResolver;
|
||||
|
||||
private TopDownAnalyzer topDownAnalyzer;
|
||||
private TopLevelDescriptorProvider topLevelDescriptorProvider;
|
||||
|
||||
private FileScopeProvider fileScopeProvider;
|
||||
|
||||
private DeclarationScopeProvider declarationScopeProvider;
|
||||
|
||||
@Inject
|
||||
public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) {
|
||||
this.resolveSession = kotlinCodeAnalyzer;
|
||||
public void setLazyDeclarationResolver(@NotNull LazyDeclarationResolver lazyDeclarationResolver) {
|
||||
this.lazyDeclarationResolver = lazyDeclarationResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setTopLevelDescriptorProvider(@NotNull TopLevelDescriptorProvider topLevelDescriptorProvider) {
|
||||
this.topLevelDescriptorProvider = topLevelDescriptorProvider;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setFileScopeProvider(@NotNull FileScopeProvider fileScopeProvider) {
|
||||
this.fileScopeProvider = fileScopeProvider;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setDeclarationScopeProvider(DeclarationScopeProviderImpl declarationScopeProvider) {
|
||||
this.declarationScopeProvider = declarationScopeProvider;
|
||||
}
|
||||
|
||||
@Inject
|
||||
@@ -102,46 +117,16 @@ public class LazyTopDownAnalyzer {
|
||||
this.bodyResolver = bodyResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setTopDownAnalyzer(@NotNull TopDownAnalyzer topDownAnalyzer) {
|
||||
this.topDownAnalyzer = topDownAnalyzer;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public TopDownAnalysisContext analyzeFiles(
|
||||
@NotNull TopDownAnalysisParameters topDownAnalysisParameters,
|
||||
@NotNull Collection<JetFile> files,
|
||||
@NotNull List<? extends PackageFragmentProvider> additionalProviders
|
||||
) {
|
||||
if (!topDownAnalysisParameters.isLazy()) {
|
||||
return topDownAnalyzer.analyzeFiles(
|
||||
topDownAnalysisParameters, files,
|
||||
additionalProviders.toArray(new PackageFragmentProvider[additionalProviders.size()]));
|
||||
}
|
||||
|
||||
PackageFragmentProvider provider;
|
||||
if (additionalProviders.isEmpty()) {
|
||||
provider = resolveSession.getPackageFragmentProvider();
|
||||
}
|
||||
else {
|
||||
provider = new CompositePackageFragmentProvider(KotlinPackage.plus(
|
||||
Arrays.asList(resolveSession.getPackageFragmentProvider()),
|
||||
additionalProviders));
|
||||
}
|
||||
|
||||
((ModuleDescriptorImpl) resolveSession.getModuleDescriptor()).initialize(provider);
|
||||
|
||||
return analyzeDeclarations(topDownAnalysisParameters, files);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public TopDownAnalysisContext analyzeDeclarations(
|
||||
@NotNull TopDownAnalysisParameters topDownAnalysisParameters,
|
||||
@NotNull Collection<? extends PsiElement> declarations
|
||||
@NotNull Collection<? extends PsiElement> declarations,
|
||||
@NotNull DataFlowInfo outerDataFlowInfo
|
||||
) {
|
||||
assert topDownAnalysisParameters.isLazy() : "Lazy analyzer is run in non-lazy mode";
|
||||
|
||||
final TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters);
|
||||
final TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters, outerDataFlowInfo);
|
||||
|
||||
final Multimap<FqName, JetElement> topLevelFqNames = HashMultimap.create();
|
||||
|
||||
final List<JetProperty> properties = new ArrayList<JetProperty>();
|
||||
@@ -169,7 +154,7 @@ public class LazyTopDownAnalyzer {
|
||||
assert script != null;
|
||||
|
||||
DescriptorResolver.registerFileInPackage(trace, file);
|
||||
c.getScripts().put(script, resolveSession.getScriptDescriptor(script));
|
||||
c.getScripts().put(script, topLevelDescriptorProvider.getScriptDescriptor(script));
|
||||
}
|
||||
else {
|
||||
JetPackageDirective packageDirective = file.getPackageDirective();
|
||||
@@ -193,14 +178,14 @@ public class LazyTopDownAnalyzer {
|
||||
|
||||
@Override
|
||||
public void visitImportDirective(@NotNull JetImportDirective importDirective) {
|
||||
LazyFileScope fileScope = resolveSession.getScopeProvider().getFileScope(
|
||||
LazyFileScope fileScope = (LazyFileScope) fileScopeProvider.getFileScope(
|
||||
importDirective.getContainingJetFile());
|
||||
fileScope.forceResolveImport(importDirective);
|
||||
}
|
||||
|
||||
private void visitClassOrObject(@NotNull JetClassOrObject classOrObject) {
|
||||
ClassDescriptorWithResolutionScopes descriptor =
|
||||
(ClassDescriptorWithResolutionScopes) resolveSession.getClassDescriptor(classOrObject);
|
||||
(ClassDescriptorWithResolutionScopes) lazyDeclarationResolver.getClassDescriptor(classOrObject);
|
||||
|
||||
c.getDeclaredClasses().put(classOrObject, descriptor);
|
||||
registerDeclarations(classOrObject.getDeclarations());
|
||||
@@ -235,7 +220,7 @@ public class LazyTopDownAnalyzer {
|
||||
if (jetParameter.hasValOrVarNode()) {
|
||||
c.getPrimaryConstructorParameterProperties().put(
|
||||
jetParameter,
|
||||
(PropertyDescriptor) resolveSession.resolveToDescriptor(jetParameter)
|
||||
(PropertyDescriptor) lazyDeclarationResolver.resolveToDescriptor(jetParameter)
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -258,11 +243,11 @@ public class LazyTopDownAnalyzer {
|
||||
|
||||
@Override
|
||||
public void visitAnonymousInitializer(@NotNull JetClassInitializer initializer) {
|
||||
registerScope(c, resolveSession, initializer);
|
||||
registerScope(c, initializer);
|
||||
JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(initializer, JetClassOrObject.class);
|
||||
c.getAnonymousInitializers().put(
|
||||
initializer,
|
||||
(ClassDescriptorWithResolutionScopes) resolveSession.resolveToDescriptor(classOrObject)
|
||||
(ClassDescriptorWithResolutionScopes) lazyDeclarationResolver.resolveToDescriptor(classOrObject)
|
||||
);
|
||||
}
|
||||
|
||||
@@ -289,13 +274,13 @@ public class LazyTopDownAnalyzer {
|
||||
);
|
||||
}
|
||||
|
||||
createFunctionDescriptors(c, resolveSession, functions);
|
||||
createFunctionDescriptors(c, functions);
|
||||
|
||||
createPropertyDescriptors(c, resolveSession, topLevelFqNames, properties);
|
||||
createPropertyDescriptors(c, topLevelFqNames, properties);
|
||||
|
||||
resolveAllHeadersInClasses(c);
|
||||
|
||||
declarationResolver.checkRedeclarationsInPackages(resolveSession, topLevelFqNames);
|
||||
declarationResolver.checkRedeclarationsInPackages(topLevelDescriptorProvider, topLevelFqNames);
|
||||
declarationResolver.checkRedeclarationsInInnerClassNames(c);
|
||||
|
||||
ResolveUtilPackage.checkTraitRequirements(c.getDeclaredClasses(), trace);
|
||||
@@ -304,9 +289,7 @@ public class LazyTopDownAnalyzer {
|
||||
|
||||
varianceChecker.check(c);
|
||||
|
||||
resolveImportsInAllFiles(c, resolveSession);
|
||||
|
||||
declarationResolver.resolveAnnotationsOnFiles(c, resolveSession.getScopeProvider());
|
||||
declarationResolver.resolveAnnotationsOnFiles(c, fileScopeProvider);
|
||||
|
||||
overloadResolver.process(c);
|
||||
|
||||
@@ -315,68 +298,50 @@ public class LazyTopDownAnalyzer {
|
||||
return c;
|
||||
}
|
||||
|
||||
private static void resolveImportsInAllFiles(TopDownAnalysisContext c, KotlinCodeAnalyzer resolveSession) {
|
||||
for (JetFile file : c.getFiles()) {
|
||||
resolveAndCheckImports(file, resolveSession);
|
||||
}
|
||||
|
||||
for (JetScript script : c.getScripts().keySet()) {
|
||||
resolveAndCheckImports(script.getContainingJetFile(), resolveSession);
|
||||
}
|
||||
}
|
||||
|
||||
private static void resolveAllHeadersInClasses(TopDownAnalysisContext c) {
|
||||
for (ClassDescriptorWithResolutionScopes classDescriptor : c.getAllClasses()) {
|
||||
((LazyClassDescriptor) classDescriptor).resolveMemberHeaders();
|
||||
}
|
||||
}
|
||||
|
||||
private static void createPropertyDescriptors(
|
||||
private void createPropertyDescriptors(
|
||||
TopDownAnalysisContext c,
|
||||
KotlinCodeAnalyzer resolveSession,
|
||||
Multimap<FqName, JetElement> topLevelFqNames,
|
||||
List<JetProperty> properties
|
||||
) {
|
||||
for (JetProperty property : properties) {
|
||||
PropertyDescriptor descriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(property);
|
||||
PropertyDescriptor descriptor = (PropertyDescriptor) lazyDeclarationResolver.resolveToDescriptor(property);
|
||||
|
||||
c.getProperties().put(property, descriptor);
|
||||
registerTopLevelFqName(topLevelFqNames, property, descriptor);
|
||||
|
||||
registerScope(c, resolveSession, property);
|
||||
registerScope(c, resolveSession, property.getGetter());
|
||||
registerScope(c, resolveSession, property.getSetter());
|
||||
registerScope(c, property);
|
||||
registerScope(c, property.getGetter());
|
||||
registerScope(c, property.getSetter());
|
||||
}
|
||||
}
|
||||
|
||||
private static void createFunctionDescriptors(
|
||||
private void createFunctionDescriptors(
|
||||
TopDownAnalysisContext c,
|
||||
KotlinCodeAnalyzer resolveSession,
|
||||
List<JetNamedFunction> functions
|
||||
) {
|
||||
for (JetNamedFunction function : functions) {
|
||||
c.getFunctions().put(
|
||||
function,
|
||||
(SimpleFunctionDescriptor) resolveSession.resolveToDescriptor(function)
|
||||
(SimpleFunctionDescriptor) lazyDeclarationResolver.resolveToDescriptor(function)
|
||||
);
|
||||
registerScope(c, resolveSession, function);
|
||||
registerScope(c, function);
|
||||
}
|
||||
}
|
||||
|
||||
private static void resolveAndCheckImports(@NotNull JetFile file, @NotNull KotlinCodeAnalyzer resolveSession) {
|
||||
LazyFileScope fileScope = resolveSession.getScopeProvider().getFileScope(file);
|
||||
fileScope.forceResolveAllImports();
|
||||
}
|
||||
|
||||
private static void registerScope(
|
||||
private void registerScope(
|
||||
@NotNull TopDownAnalysisContext c,
|
||||
@NotNull KotlinCodeAnalyzer resolveSession,
|
||||
@Nullable JetDeclaration declaration
|
||||
) {
|
||||
if (declaration == null) return;
|
||||
c.registerDeclaringScope(
|
||||
declaration,
|
||||
resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration)
|
||||
declarationScopeProvider.getResolutionScopeForDeclaration(declaration)
|
||||
);
|
||||
}
|
||||
|
||||
@@ -392,11 +357,6 @@ public class LazyTopDownAnalyzer {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public KotlinCodeAnalyzer getCodeAnalyzer() {
|
||||
return resolveSession;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve;
|
||||
|
||||
import kotlin.KotlinPackage;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
|
||||
import org.jetbrains.kotlin.psi.JetFile;
|
||||
import org.jetbrains.kotlin.psi.JetScript;
|
||||
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
|
||||
import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyFileScope;
|
||||
|
||||
import javax.inject.Inject;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
|
||||
public class LazyTopDownAnalyzerForTopLevel {
|
||||
|
||||
private KotlinCodeAnalyzer resolveSession;
|
||||
private LazyTopDownAnalyzer lazyTopDownAnalyzer;
|
||||
|
||||
@Inject
|
||||
public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) {
|
||||
this.resolveSession = kotlinCodeAnalyzer;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setLazyTopDownAnalyzer(@NotNull LazyTopDownAnalyzer lazyTopDownAnalyzer) {
|
||||
this.lazyTopDownAnalyzer = lazyTopDownAnalyzer;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public TopDownAnalysisContext analyzeFiles(
|
||||
@NotNull TopDownAnalysisParameters topDownAnalysisParameters,
|
||||
@NotNull Collection<JetFile> files,
|
||||
@NotNull List<? extends PackageFragmentProvider> additionalProviders
|
||||
) {
|
||||
assert topDownAnalysisParameters.isLazy() : "Lazy analyzer is run in non-lazy mode";
|
||||
|
||||
PackageFragmentProvider provider;
|
||||
if (additionalProviders.isEmpty()) {
|
||||
provider = resolveSession.getPackageFragmentProvider();
|
||||
}
|
||||
else {
|
||||
provider = new CompositePackageFragmentProvider(KotlinPackage.plus(
|
||||
Arrays.asList(resolveSession.getPackageFragmentProvider()),
|
||||
additionalProviders));
|
||||
}
|
||||
|
||||
((ModuleDescriptorImpl) resolveSession.getModuleDescriptor()).initialize(provider);
|
||||
|
||||
TopDownAnalysisContext c = lazyTopDownAnalyzer.analyzeDeclarations(topDownAnalysisParameters, files, DataFlowInfo.EMPTY);
|
||||
|
||||
resolveImportsInAllFiles(c, resolveSession);
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
private static void resolveImportsInAllFiles(TopDownAnalysisContext c, KotlinCodeAnalyzer resolveSession) {
|
||||
for (JetFile file : c.getFiles()) {
|
||||
resolveAndCheckImports(file, resolveSession);
|
||||
}
|
||||
|
||||
for (JetScript script : c.getScripts().keySet()) {
|
||||
resolveAndCheckImports(script.getContainingJetFile(), resolveSession);
|
||||
}
|
||||
}
|
||||
|
||||
private static void resolveAndCheckImports(@NotNull JetFile file, @NotNull KotlinCodeAnalyzer resolveSession) {
|
||||
LazyFileScope fileScope = resolveSession.getScopeProvider().getFileScope(file);
|
||||
fileScope.forceResolveAllImports();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -33,7 +33,6 @@ import org.jetbrains.annotations.ReadOnly;
|
||||
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
|
||||
import org.jetbrains.kotlin.descriptors.*;
|
||||
import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor;
|
||||
import org.jetbrains.kotlin.lexer.JetTokens;
|
||||
import org.jetbrains.kotlin.name.Name;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
@@ -63,89 +62,12 @@ public class OverrideResolver {
|
||||
|
||||
|
||||
|
||||
public void process(@NotNull TopDownAnalysisContext c) {
|
||||
//all created fake descriptors are stored to resolve visibility on them later
|
||||
generateOverridesAndDelegation(c);
|
||||
|
||||
check(c);
|
||||
}
|
||||
|
||||
public void check(@NotNull TopDownAnalysisContext c) {
|
||||
checkVisibility(c);
|
||||
checkOverrides(c);
|
||||
checkParameterOverridesForAllClasses(c);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate fake overrides and add overridden descriptors to existing descriptors.
|
||||
*/
|
||||
private void generateOverridesAndDelegation(@NotNull TopDownAnalysisContext c) {
|
||||
Set<ClassDescriptorWithResolutionScopes> ourClasses = new HashSet<ClassDescriptorWithResolutionScopes>(c.getAllClasses());
|
||||
Set<ClassifierDescriptor> processed = new HashSet<ClassifierDescriptor>();
|
||||
|
||||
for (MutableClassDescriptor klass : ContainerUtil.reverse(c.getClassesTopologicalOrder())) {
|
||||
if (ourClasses.contains(klass)) {
|
||||
generateOverridesAndDelegationInAClass(klass, processed, ourClasses);
|
||||
|
||||
MutableClassDescriptor classObject = klass.getClassObjectDescriptor();
|
||||
if (classObject != null) {
|
||||
generateOverridesAndDelegationInAClass(classObject, processed, ourClasses);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void generateOverridesAndDelegationInAClass(
|
||||
@NotNull MutableClassDescriptor classDescriptor,
|
||||
@NotNull Set<ClassifierDescriptor> processed,
|
||||
@NotNull Set<ClassDescriptorWithResolutionScopes> classesBeingAnalyzed
|
||||
// to filter out classes such as stdlib and others that come from dependencies
|
||||
) {
|
||||
if (!processed.add(classDescriptor)) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
|
||||
ClassDescriptor superclass = (ClassDescriptor) supertype.getConstructor().getDeclarationDescriptor();
|
||||
if (superclass instanceof MutableClassDescriptor && classesBeingAnalyzed.contains(superclass)) {
|
||||
generateOverridesAndDelegationInAClass((MutableClassDescriptor) superclass, processed, classesBeingAnalyzed);
|
||||
}
|
||||
}
|
||||
|
||||
JetClassOrObject classOrObject = (JetClassOrObject) DescriptorToSourceUtils.classDescriptorToDeclaration(classDescriptor);
|
||||
if (classOrObject != null) {
|
||||
DelegationResolver.generateDelegatesInAClass(classDescriptor, trace, classOrObject);
|
||||
}
|
||||
|
||||
generateOverridesInAClass(classDescriptor);
|
||||
}
|
||||
|
||||
private void generateOverridesInAClass(@NotNull final MutableClassDescriptor classDescriptor) {
|
||||
generateOverridesInAClass(classDescriptor, classDescriptor.getDeclaredCallableMembers(), new OverridingUtil.DescriptorSink() {
|
||||
@Override
|
||||
public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
|
||||
if (fakeOverride instanceof PropertyDescriptor) {
|
||||
classDescriptor.getBuilder().addPropertyDescriptor((PropertyDescriptor) fakeOverride);
|
||||
}
|
||||
else if (fakeOverride instanceof SimpleFunctionDescriptor) {
|
||||
classDescriptor.getBuilder().addFunctionDescriptor((SimpleFunctionDescriptor) fakeOverride);
|
||||
}
|
||||
else {
|
||||
throw new IllegalStateException(fakeOverride.getClass().getName());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent) {
|
||||
JetDeclaration declaration = (JetDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(fromCurrent);
|
||||
//noinspection ConstantConditions
|
||||
trace.report(CONFLICTING_OVERLOADS.on(declaration, fromCurrent, fromCurrent.getContainingDeclaration().getName().asString()));
|
||||
}
|
||||
});
|
||||
|
||||
resolveUnknownVisibilities(classDescriptor.getAllCallableMembers(), trace);
|
||||
}
|
||||
|
||||
public static void generateOverridesInAClass(
|
||||
@NotNull ClassDescriptor classDescriptor,
|
||||
@NotNull Collection<CallableMemberDescriptor> membersFromCurrent,
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve;
|
||||
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.descriptors.ClassDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
|
||||
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
|
||||
import org.jetbrains.kotlin.psi.JetElement;
|
||||
import org.jetbrains.kotlin.psi.JetExpression;
|
||||
import org.jetbrains.kotlin.psi.JetImportDirective;
|
||||
|
||||
import java.util.Collection;
|
||||
|
||||
import static org.jetbrains.kotlin.diagnostics.Errors.PLATFORM_CLASS_MAPPED_TO_KOTLIN;
|
||||
|
||||
public class PlatformTypesMappedToKotlinChecker {
|
||||
|
||||
public static void checkPlatformTypesMappedToKotlin(
|
||||
@NotNull ModuleDescriptor module,
|
||||
@NotNull BindingTrace trace,
|
||||
@NotNull JetImportDirective importDirective,
|
||||
@NotNull Collection<? extends DeclarationDescriptor> descriptors
|
||||
) {
|
||||
JetExpression importedReference = importDirective.getImportedReference();
|
||||
if (importedReference != null) {
|
||||
for (DeclarationDescriptor descriptor : descriptors) {
|
||||
reportPlatformClassMappedToKotlin(module, trace, importedReference, descriptor);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void reportPlatformClassMappedToKotlin(
|
||||
@NotNull ModuleDescriptor module,
|
||||
@NotNull BindingTrace trace,
|
||||
@NotNull JetElement element,
|
||||
@NotNull DeclarationDescriptor descriptor
|
||||
) {
|
||||
if (!(descriptor instanceof ClassDescriptor)) return;
|
||||
|
||||
PlatformToKotlinClassMap platformToKotlinMap = module.getPlatformToKotlinClassMap();
|
||||
Collection<ClassDescriptor> kotlinAnalogsForClass = platformToKotlinMap.mapPlatformClass((ClassDescriptor) descriptor);
|
||||
if (!kotlinAnalogsForClass.isEmpty()) {
|
||||
trace.report(PLATFORM_CLASS_MAPPED_TO_KOTLIN.on(element, kotlinAnalogsForClass));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -39,7 +39,7 @@ import java.util.*;
|
||||
|
||||
public class TopDownAnalysisContext implements BodiesResolveContext {
|
||||
|
||||
private DataFlowInfo outerDataFlowInfo = DataFlowInfo.EMPTY;
|
||||
private final DataFlowInfo outerDataFlowInfo;
|
||||
|
||||
private final Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> classes = Maps.newLinkedHashMap();
|
||||
private final Map<JetClassInitializer, ClassDescriptorWithResolutionScopes> anonymousInitializers = Maps.newLinkedHashMap();
|
||||
@@ -66,8 +66,9 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
|
||||
|
||||
private StringBuilder debugOutput;
|
||||
|
||||
public TopDownAnalysisContext(@NotNull TopDownAnalysisParameters topDownAnalysisParameters) {
|
||||
public TopDownAnalysisContext(@NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull DataFlowInfo outerDataFlowInfo) {
|
||||
this.topDownAnalysisParameters = topDownAnalysisParameters;
|
||||
this.outerDataFlowInfo = outerDataFlowInfo;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -199,10 +200,6 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
|
||||
return outerDataFlowInfo;
|
||||
}
|
||||
|
||||
public void setOuterDataFlowInfo(@NotNull DataFlowInfo outerDataFlowInfo) {
|
||||
this.outerDataFlowInfo = outerDataFlowInfo;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public Collection<ClassDescriptorWithResolutionScopes> getAllClasses() {
|
||||
// SCRIPT: all classes are declared classes + script classes
|
||||
|
||||
@@ -1,178 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve;
|
||||
|
||||
import com.google.common.collect.Sets;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import kotlin.KotlinPackage;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.descriptors.ClassDescriptorWithResolutionScopes;
|
||||
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.descriptors.impl.*;
|
||||
import org.jetbrains.kotlin.name.FqName;
|
||||
import org.jetbrains.kotlin.psi.JetFile;
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope;
|
||||
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
|
||||
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
|
||||
|
||||
import javax.inject.Inject;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
@Deprecated
|
||||
public class TopDownAnalyzer {
|
||||
|
||||
private DeclarationResolver declarationResolver;
|
||||
private TypeHierarchyResolver typeHierarchyResolver;
|
||||
private OverrideResolver overrideResolver;
|
||||
private VarianceChecker varianceChecker;
|
||||
private OverloadResolver overloadResolver;
|
||||
private ModuleDescriptor moduleDescriptor;
|
||||
private MutablePackageFragmentProvider packageFragmentProvider;
|
||||
private BodyResolver bodyResolver;
|
||||
|
||||
public TopDownAnalyzer() {
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setDeclarationResolver(@NotNull DeclarationResolver declarationResolver) {
|
||||
this.declarationResolver = declarationResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setTypeHierarchyResolver(@NotNull TypeHierarchyResolver typeHierarchyResolver) {
|
||||
this.typeHierarchyResolver = typeHierarchyResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setOverrideResolver(@NotNull OverrideResolver overrideResolver) {
|
||||
this.overrideResolver = overrideResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setVarianceChecker(@NotNull VarianceChecker varianceChecker) {
|
||||
this.varianceChecker = varianceChecker;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setOverloadResolver(@NotNull OverloadResolver overloadResolver) {
|
||||
this.overloadResolver = overloadResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) {
|
||||
this.moduleDescriptor = moduleDescriptor;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setPackageFragmentProvider(@NotNull MutablePackageFragmentProvider packageFragmentProvider) {
|
||||
this.packageFragmentProvider = packageFragmentProvider;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setBodyResolver(@NotNull BodyResolver bodyResolver) {
|
||||
this.bodyResolver = bodyResolver;
|
||||
}
|
||||
|
||||
public void doProcess(
|
||||
@NotNull TopDownAnalysisContext c,
|
||||
@NotNull JetScope outerScope,
|
||||
@NotNull PackageLikeBuilder owner,
|
||||
@NotNull Collection<? extends PsiElement> declarations
|
||||
) {
|
||||
// c.enableDebugOutput();
|
||||
c.debug("Enter");
|
||||
|
||||
typeHierarchyResolver.process(c, outerScope, owner, declarations);
|
||||
declarationResolver.process(c);
|
||||
overrideResolver.process(c);
|
||||
varianceChecker.process(c);
|
||||
lockScopes(c);
|
||||
|
||||
overloadResolver.process(c);
|
||||
|
||||
if (!c.getTopDownAnalysisParameters().isAnalyzingBootstrapLibrary()) {
|
||||
bodyResolver.resolveBodies(c);
|
||||
}
|
||||
|
||||
c.debug("Exit");
|
||||
//noinspection UseOfSystemOutOrSystemErr
|
||||
c.printDebugOutput(System.out);
|
||||
}
|
||||
|
||||
private void lockScopes(@NotNull TopDownAnalysisContext c) {
|
||||
for (ClassDescriptorWithResolutionScopes mutableClassDescriptor : c.getDeclaredClasses().values()) {
|
||||
((MutableClassDescriptor) mutableClassDescriptor).lockScopes();
|
||||
}
|
||||
|
||||
// SCRIPT: extra code for scripts
|
||||
Set<FqName> scriptFqNames = Sets.newHashSet();
|
||||
for (JetFile file : c.getFileScopes().keySet()) {
|
||||
if (file.isScript()) {
|
||||
scriptFqNames.add(file.getPackageFqName());
|
||||
}
|
||||
}
|
||||
for (MutablePackageFragmentDescriptor fragment : packageFragmentProvider.getAllFragments()) {
|
||||
// todo: this is hack in favor of REPL
|
||||
if (!scriptFqNames.contains(fragment.getFqName())) {
|
||||
fragment.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public TopDownAnalysisContext analyzeFiles(
|
||||
@NotNull TopDownAnalysisParameters topDownAnalysisParameters,
|
||||
@NotNull Collection<JetFile> files,
|
||||
@NotNull PackageFragmentProvider... additionalProviders
|
||||
) {
|
||||
return analyzeFiles(topDownAnalysisParameters, files, Arrays.asList(additionalProviders));
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public TopDownAnalysisContext analyzeFiles(
|
||||
@NotNull TopDownAnalysisParameters topDownAnalysisParameters,
|
||||
@NotNull Collection<JetFile> files,
|
||||
@NotNull List<PackageFragmentProvider> additionalProviders
|
||||
) {
|
||||
//noinspection deprecation
|
||||
assert !topDownAnalysisParameters.isLazy() : "Lazy resolve must be disabled for this method";
|
||||
|
||||
TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters);
|
||||
CompositePackageFragmentProvider provider =
|
||||
new CompositePackageFragmentProvider(KotlinPackage.plus(Arrays.asList(packageFragmentProvider), additionalProviders));
|
||||
|
||||
((ModuleDescriptorImpl) moduleDescriptor).initialize(provider);
|
||||
|
||||
// dummy builder is used because "root" is module descriptor,
|
||||
// packages added to module explicitly in
|
||||
doProcess(c, JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor), new PackageLikeBuilderDummy(), files);
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
@NotNull
|
||||
public MutablePackageFragmentProvider getPackageFragmentProvider() {
|
||||
return packageFragmentProvider;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,505 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve;
|
||||
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiNameIdentifierOwner;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.jetbrains.kotlin.descriptors.*;
|
||||
import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl;
|
||||
import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.impl.PackageLikeBuilder;
|
||||
import org.jetbrains.kotlin.name.Name;
|
||||
import org.jetbrains.kotlin.name.SpecialNames;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
import org.jetbrains.kotlin.resolve.scopes.ChainedScope;
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope;
|
||||
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
|
||||
import org.jetbrains.kotlin.resolve.scopes.WriteThroughScope;
|
||||
import org.jetbrains.kotlin.types.JetType;
|
||||
import org.jetbrains.kotlin.utils.DFS;
|
||||
|
||||
import javax.inject.Inject;
|
||||
import java.util.*;
|
||||
|
||||
import static org.jetbrains.kotlin.diagnostics.Errors.*;
|
||||
import static org.jetbrains.kotlin.name.SpecialNames.getClassObjectName;
|
||||
import static org.jetbrains.kotlin.resolve.BindingContext.FQNAME_TO_CLASS_DESCRIPTOR;
|
||||
import static org.jetbrains.kotlin.resolve.BindingContext.TYPE;
|
||||
import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry;
|
||||
import static org.jetbrains.kotlin.resolve.DescriptorUtils.isObject;
|
||||
import static org.jetbrains.kotlin.resolve.ModifiersChecker.getDefaultClassVisibility;
|
||||
import static org.jetbrains.kotlin.resolve.ModifiersChecker.resolveVisibilityFromModifiers;
|
||||
import static org.jetbrains.kotlin.resolve.source.SourcePackage.toSourceElement;
|
||||
|
||||
public class TypeHierarchyResolver {
|
||||
private static final DFS.Neighbors<ClassDescriptor> CLASS_INHERITANCE_EDGES = new DFS.Neighbors<ClassDescriptor>() {
|
||||
@NotNull
|
||||
@Override
|
||||
public Iterable<ClassDescriptor> getNeighbors(ClassDescriptor current) {
|
||||
List<ClassDescriptor> result = new ArrayList<ClassDescriptor>();
|
||||
for (JetType supertype : current.getDefaultType().getConstructor().getSupertypes()) {
|
||||
DeclarationDescriptor descriptor = supertype.getConstructor().getDeclarationDescriptor();
|
||||
if (descriptor instanceof ClassDescriptor) {
|
||||
result.add((ClassDescriptor) descriptor);
|
||||
}
|
||||
}
|
||||
DeclarationDescriptor container = current.getContainingDeclaration();
|
||||
if (container instanceof ClassDescriptor) {
|
||||
result.add((ClassDescriptor) container);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
@NotNull
|
||||
private ImportsResolver importsResolver;
|
||||
@NotNull
|
||||
private DescriptorResolver descriptorResolver;
|
||||
@NotNull
|
||||
private ScriptHeaderResolver scriptHeaderResolver;
|
||||
@NotNull
|
||||
private MutablePackageFragmentProvider packageFragmentProvider;
|
||||
@NotNull
|
||||
private BindingTrace trace;
|
||||
|
||||
@Inject
|
||||
public void setImportsResolver(@NotNull ImportsResolver importsResolver) {
|
||||
this.importsResolver = importsResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) {
|
||||
this.descriptorResolver = descriptorResolver;
|
||||
}
|
||||
|
||||
// SCRIPT: inject script header resolver
|
||||
@Inject
|
||||
public void setScriptHeaderResolver(@NotNull ScriptHeaderResolver scriptHeaderResolver) {
|
||||
this.scriptHeaderResolver = scriptHeaderResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setPackageFragmentProvider(@NotNull MutablePackageFragmentProvider packageFragmentProvider) {
|
||||
this.packageFragmentProvider = packageFragmentProvider;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setTrace(@NotNull BindingTrace trace) {
|
||||
this.trace = trace;
|
||||
}
|
||||
|
||||
public void process(
|
||||
@NotNull TopDownAnalysisContext c,
|
||||
@NotNull JetScope outerScope,
|
||||
@NotNull PackageLikeBuilder owner,
|
||||
@NotNull Collection<? extends PsiElement> declarations
|
||||
) {
|
||||
|
||||
{
|
||||
// TODO: Very temp code - main goal is to remove recursion from collectPackageFragmentsAndClassifiers
|
||||
Queue<JetDeclarationContainer> forDeferredResolve = new LinkedList<JetDeclarationContainer>();
|
||||
forDeferredResolve.addAll(collectPackageFragmentsAndClassifiers(c, outerScope, owner, declarations));
|
||||
|
||||
while (!forDeferredResolve.isEmpty()) {
|
||||
JetDeclarationContainer declarationContainer = forDeferredResolve.poll();
|
||||
assert declarationContainer != null;
|
||||
|
||||
DeclarationDescriptor descriptorForDeferredResolve = c.forDeferredResolver.get(declarationContainer);
|
||||
JetScope scope = c.normalScope.get(declarationContainer);
|
||||
|
||||
// Even more temp code
|
||||
if (descriptorForDeferredResolve instanceof MutableClassDescriptor) {
|
||||
forDeferredResolve.addAll(
|
||||
collectPackageFragmentsAndClassifiers(
|
||||
c,
|
||||
scope,
|
||||
((MutableClassDescriptor) descriptorForDeferredResolve).getBuilder(),
|
||||
declarationContainer.getDeclarations()));
|
||||
}
|
||||
else if (descriptorForDeferredResolve instanceof MutablePackageFragmentDescriptor) {
|
||||
forDeferredResolve.addAll(
|
||||
collectPackageFragmentsAndClassifiers(
|
||||
c,
|
||||
scope,
|
||||
((MutablePackageFragmentDescriptor) descriptorForDeferredResolve).getBuilder(),
|
||||
declarationContainer.getDeclarations()));
|
||||
}
|
||||
else {
|
||||
assert false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
importsResolver.processTypeImports(c);
|
||||
|
||||
createTypeConstructors(c); // create type constructors for classes and generic parameters, supertypes are not filled in
|
||||
resolveTypesInClassHeaders(c); // Generic bounds and types in supertype lists (no expressions or constructor resolution)
|
||||
|
||||
c.setClassesTopologicalOrder(topologicallySortClassesAndObjects(c));
|
||||
|
||||
// Detect and disconnect all loops in the hierarchy
|
||||
detectAndDisconnectLoops(c);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private Collection<JetDeclarationContainer> collectPackageFragmentsAndClassifiers(
|
||||
@NotNull TopDownAnalysisContext c,
|
||||
@NotNull JetScope outerScope,
|
||||
@NotNull PackageLikeBuilder owner,
|
||||
@NotNull Iterable<? extends PsiElement> declarations
|
||||
) {
|
||||
Collection<JetDeclarationContainer> forDeferredResolve = new ArrayList<JetDeclarationContainer>();
|
||||
|
||||
ClassifierCollector collector = new ClassifierCollector(c, outerScope, owner, forDeferredResolve);
|
||||
|
||||
for (PsiElement declaration : declarations) {
|
||||
declaration.accept(collector);
|
||||
}
|
||||
|
||||
return forDeferredResolve;
|
||||
}
|
||||
|
||||
|
||||
@NotNull
|
||||
private static ClassKind getClassKind(@NotNull JetClass jetClass) {
|
||||
if (jetClass.isTrait()) return ClassKind.TRAIT;
|
||||
if (jetClass.isAnnotation()) return ClassKind.ANNOTATION_CLASS;
|
||||
if (jetClass.isEnum()) return ClassKind.ENUM_CLASS;
|
||||
return ClassKind.CLASS;
|
||||
}
|
||||
|
||||
private void createTypeConstructors(@NotNull TopDownAnalysisContext c) {
|
||||
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
|
||||
JetClassOrObject classOrObject = entry.getKey();
|
||||
MutableClassDescriptor descriptor = (MutableClassDescriptor) entry.getValue();
|
||||
if (classOrObject instanceof JetClass) {
|
||||
descriptorResolver.resolveMutableClassDescriptor(
|
||||
c.getTopDownAnalysisParameters(),
|
||||
(JetClass) classOrObject, descriptor, trace);
|
||||
}
|
||||
else if (classOrObject instanceof JetObjectDeclaration) {
|
||||
descriptor.setModality(Modality.FINAL);
|
||||
descriptor.setVisibility(resolveVisibilityFromModifiers(classOrObject, getDefaultClassVisibility(descriptor)));
|
||||
descriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
|
||||
}
|
||||
|
||||
descriptor.createTypeConstructor();
|
||||
|
||||
ClassKind kind = descriptor.getKind();
|
||||
if (kind == ClassKind.ENUM_ENTRY || kind == ClassKind.OBJECT) {
|
||||
MutableClassDescriptor classObject = descriptor.getClassObjectDescriptor();
|
||||
assert classObject != null : "Enum entries and named objects should have class objects: " + classOrObject.getText();
|
||||
|
||||
// This is a clever hack: each enum entry and object declaration (i.e. singleton) has a synthetic class object.
|
||||
// We make this class object inherit from the singleton here, thus allowing to use the singleton's class object where
|
||||
// the instance of the singleton is applicable. Effectively all members of the singleton would be present in its class
|
||||
// object as fake overrides, so you can access them via standard class object notation: ObjectName.memberName()
|
||||
classObject.setSupertypes(Collections.singleton(descriptor.getDefaultType()));
|
||||
|
||||
classObject.createTypeConstructor();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void resolveTypesInClassHeaders(@NotNull TopDownAnalysisContext c) {
|
||||
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
|
||||
JetClassOrObject classOrObject = entry.getKey();
|
||||
if (classOrObject instanceof JetClass) {
|
||||
ClassDescriptorWithResolutionScopes descriptor = entry.getValue();
|
||||
//noinspection unchecked
|
||||
descriptorResolver.resolveGenericBounds((JetClass) classOrObject, descriptor, descriptor.getScopeForClassHeaderResolution(),
|
||||
(List) descriptor.getTypeConstructor().getParameters(), trace);
|
||||
}
|
||||
}
|
||||
|
||||
for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
|
||||
descriptorResolver.resolveSupertypesForMutableClassDescriptor(entry.getKey(), (MutableClassDescriptor) entry.getValue(), trace);
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@SuppressWarnings("unchecked")
|
||||
private static List<MutableClassDescriptor> topologicallySortClassesAndObjects(@NotNull TopDownAnalysisContext c) {
|
||||
Collection<ClassDescriptor> sourceClasses = (Collection) c.getAllClasses();
|
||||
List<ClassDescriptor> allClassesOrdered = DFS.topologicalOrder(sourceClasses, CLASS_INHERITANCE_EDGES);
|
||||
allClassesOrdered.retainAll(sourceClasses);
|
||||
return (List) allClassesOrdered;
|
||||
}
|
||||
|
||||
private void detectAndDisconnectLoops(@NotNull TopDownAnalysisContext c) {
|
||||
List<Runnable> tasks = new ArrayList<Runnable>();
|
||||
for (final MutableClassDescriptor klass : c.getClassesTopologicalOrder()) {
|
||||
for (final JetType supertype : klass.getSupertypes()) {
|
||||
ClassifierDescriptor supertypeDescriptor = supertype.getConstructor().getDeclarationDescriptor();
|
||||
if (supertypeDescriptor instanceof ClassDescriptor) {
|
||||
ClassDescriptor superclass = (ClassDescriptor) supertypeDescriptor;
|
||||
if (isReachable(superclass, klass, new HashSet<ClassDescriptor>())) {
|
||||
tasks.add(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
klass.getSupertypes().remove(supertype);
|
||||
}
|
||||
});
|
||||
reportCyclicInheritanceHierarchyError(trace, klass, superclass);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (Runnable task : tasks) {
|
||||
task.run();
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: use DFS and copy to LazyClassTypeConstructor.isReachable
|
||||
private static boolean isReachable(
|
||||
@NotNull ClassDescriptor from,
|
||||
@NotNull MutableClassDescriptor to,
|
||||
@NotNull Set<ClassDescriptor> visited
|
||||
) {
|
||||
if (!visited.add(from)) return false;
|
||||
for (ClassDescriptor superclass : CLASS_INHERITANCE_EDGES.getNeighbors(from)) {
|
||||
if (superclass == to || isReachable(superclass, to, visited)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static void reportCyclicInheritanceHierarchyError(
|
||||
@NotNull BindingTrace trace,
|
||||
@NotNull ClassDescriptor classDescriptor,
|
||||
@NotNull ClassDescriptor superclass
|
||||
) {
|
||||
PsiElement psiElement = DescriptorToSourceUtils.classDescriptorToDeclaration(classDescriptor);
|
||||
|
||||
PsiElement elementToMark = null;
|
||||
if (psiElement instanceof JetClassOrObject) {
|
||||
JetClassOrObject classOrObject = (JetClassOrObject) psiElement;
|
||||
for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
|
||||
JetTypeReference typeReference = delegationSpecifier.getTypeReference();
|
||||
if (typeReference == null) continue;
|
||||
JetType supertype = trace.get(TYPE, typeReference);
|
||||
if (supertype != null && supertype.getConstructor() == superclass.getTypeConstructor()) {
|
||||
elementToMark = typeReference;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (elementToMark == null && psiElement instanceof PsiNameIdentifierOwner) {
|
||||
PsiNameIdentifierOwner namedElement = (PsiNameIdentifierOwner) psiElement;
|
||||
PsiElement nameIdentifier = namedElement.getNameIdentifier();
|
||||
if (nameIdentifier != null) {
|
||||
elementToMark = nameIdentifier;
|
||||
}
|
||||
}
|
||||
if (elementToMark != null) {
|
||||
trace.report(CYCLIC_INHERITANCE_HIERARCHY.on(elementToMark));
|
||||
}
|
||||
}
|
||||
|
||||
private class ClassifierCollector extends JetVisitorVoid {
|
||||
private final TopDownAnalysisContext c;
|
||||
private final JetScope outerScope;
|
||||
private final PackageLikeBuilder owner;
|
||||
private final Collection<JetDeclarationContainer> forDeferredResolve;
|
||||
|
||||
public ClassifierCollector(
|
||||
@NotNull TopDownAnalysisContext c,
|
||||
@NotNull JetScope outerScope,
|
||||
@NotNull PackageLikeBuilder owner,
|
||||
@NotNull Collection<JetDeclarationContainer> forDeferredResolve
|
||||
) {
|
||||
this.c = c;
|
||||
this.outerScope = outerScope;
|
||||
this.owner = owner;
|
||||
this.forDeferredResolve = forDeferredResolve;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitJetFile(@NotNull JetFile file) {
|
||||
MutablePackageFragmentDescriptor packageFragment = getOrCreatePackageFragmentForFile(file);
|
||||
c.getPackageFragments().put(file, packageFragment);
|
||||
c.addFile(file);
|
||||
|
||||
PackageViewDescriptor packageView = packageFragment.getContainingDeclaration().getPackage(packageFragment.getFqName());
|
||||
ChainedScope rootPlusPackageScope = new ChainedScope(packageView, "Root scope for " + file, packageView.getMemberScope(), outerScope);
|
||||
WriteThroughScope packageScope = new WriteThroughScope(rootPlusPackageScope, packageFragment.getMemberScope(),
|
||||
new TraceBasedRedeclarationHandler(trace), "package in file " + file.getName());
|
||||
packageScope.changeLockLevel(WritableScope.LockLevel.BOTH);
|
||||
c.getFileScopes().put(file, packageScope);
|
||||
|
||||
if (file.isScript()) {
|
||||
// SCRIPT: process script hierarchy
|
||||
scriptHeaderResolver.processScriptHierarchy(c, file.getScript(), packageScope);
|
||||
}
|
||||
|
||||
prepareForDeferredCall(packageScope, packageFragment, file);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitClass(@NotNull JetClass klass) {
|
||||
MutableClassDescriptor mutableClassDescriptor = createClassDescriptorForClass(klass, owner.getOwnerForChildren());
|
||||
|
||||
owner.addClassifierDescriptor(mutableClassDescriptor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration) {
|
||||
if (declaration.isObjectLiteral()) {
|
||||
createClassDescriptorForSingleton(declaration, SpecialNames.NO_NAME_PROVIDED, ClassKind.CLASS);
|
||||
return;
|
||||
}
|
||||
|
||||
MutableClassDescriptor descriptor =
|
||||
createClassDescriptorForSingleton(declaration, JetPsiUtil.safeName(declaration.getName()), ClassKind.OBJECT);
|
||||
|
||||
owner.addClassifierDescriptor(descriptor);
|
||||
trace.record(FQNAME_TO_CLASS_DESCRIPTOR, JetNamedDeclarationUtil.getUnsafeFQName(declaration), descriptor);
|
||||
|
||||
descriptor.getBuilder().setClassObjectDescriptor(createSyntheticClassObjectForSingleton(descriptor));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitEnumEntry(@NotNull JetEnumEntry declaration) {
|
||||
MutableClassDescriptor descriptor =
|
||||
createClassDescriptorForSingleton(declaration, JetPsiUtil.safeName(declaration.getName()), ClassKind.ENUM_ENTRY);
|
||||
|
||||
owner.addClassifierDescriptor(descriptor);
|
||||
|
||||
descriptor.getBuilder().setClassObjectDescriptor(createSyntheticClassObjectForSingleton(descriptor));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitTypedef(@NotNull JetTypedef typedef) {
|
||||
trace.report(UNSUPPORTED.on(typedef, "TypeHierarchyResolver"));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitClassObject(@NotNull JetClassObject classObject) {
|
||||
JetObjectDeclaration objectDeclaration = classObject.getObjectDeclaration();
|
||||
|
||||
DeclarationDescriptor container = owner.getOwnerForChildren();
|
||||
|
||||
MutableClassDescriptor classObjectDescriptor =
|
||||
createClassDescriptorForSingleton(objectDeclaration, getClassObjectName(container.getName()), ClassKind.CLASS_OBJECT);
|
||||
|
||||
PackageLikeBuilder.ClassObjectStatus status =
|
||||
isEnumEntry(container) || isObject(container) || c.getTopDownAnalysisParameters().isDeclaredLocally() ?
|
||||
PackageLikeBuilder.ClassObjectStatus.NOT_ALLOWED :
|
||||
owner.setClassObjectDescriptor(classObjectDescriptor);
|
||||
|
||||
switch (status) {
|
||||
case DUPLICATE:
|
||||
trace.report(MANY_CLASS_OBJECTS.on(classObject));
|
||||
break;
|
||||
case NOT_ALLOWED:
|
||||
trace.report(CLASS_OBJECT_NOT_ALLOWED.on(classObject));
|
||||
break;
|
||||
case OK:
|
||||
// Everything is OK so no errors to trace.
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private MutablePackageFragmentDescriptor getOrCreatePackageFragmentForFile(@NotNull JetFile file) {
|
||||
JetPackageDirective packageDirective = file.getPackageDirective();
|
||||
assert packageDirective != null : "scripts are not supported";
|
||||
|
||||
MutablePackageFragmentDescriptor fragment = packageFragmentProvider.getOrCreateFragment(packageDirective.getFqName());
|
||||
|
||||
ModuleDescriptor module = packageFragmentProvider.getModule();
|
||||
DescriptorResolver.resolvePackageHeader(packageDirective, module, trace);
|
||||
DescriptorResolver.registerFileInPackage(trace, file);
|
||||
trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file, fragment);
|
||||
|
||||
return fragment;
|
||||
}
|
||||
|
||||
|
||||
@NotNull
|
||||
private MutableClassDescriptor createSyntheticClassObjectForSingleton(@NotNull ClassDescriptor classDescriptor) {
|
||||
MutableClassDescriptor classObject =
|
||||
new MutableClassDescriptor(classDescriptor, outerScope, ClassKind.CLASS_OBJECT, false,
|
||||
getClassObjectName(classDescriptor.getName()), SourceElement.NO_SOURCE);
|
||||
|
||||
classObject.setModality(Modality.FINAL);
|
||||
classObject.setVisibility(DescriptorUtils.getSyntheticClassObjectVisibility());
|
||||
classObject.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
|
||||
createPrimaryConstructorForObject(null, classObject);
|
||||
return classObject;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private MutableClassDescriptor createClassDescriptorForClass(
|
||||
@NotNull JetClass klass,
|
||||
@NotNull DeclarationDescriptor containingDeclaration
|
||||
) {
|
||||
MutableClassDescriptor descriptor = new MutableClassDescriptor(
|
||||
containingDeclaration, outerScope, getClassKind(klass), klass.isInner(), JetPsiUtil.safeName(klass.getName()),
|
||||
toSourceElement(klass)
|
||||
);
|
||||
c.getDeclaredClasses().put(klass, descriptor);
|
||||
trace.record(FQNAME_TO_CLASS_DESCRIPTOR, JetNamedDeclarationUtil.getUnsafeFQName(klass), descriptor);
|
||||
|
||||
prepareForDeferredCall(descriptor.getScopeForMemberDeclarationResolution(), descriptor, klass);
|
||||
|
||||
return descriptor;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private MutableClassDescriptor createClassDescriptorForSingleton(
|
||||
@NotNull JetClassOrObject declaration,
|
||||
@NotNull Name name,
|
||||
@NotNull ClassKind kind
|
||||
) {
|
||||
MutableClassDescriptor descriptor = new MutableClassDescriptor(owner.getOwnerForChildren(), outerScope, kind, false, name,
|
||||
toSourceElement(declaration));
|
||||
|
||||
prepareForDeferredCall(descriptor.getScopeForMemberDeclarationResolution(), descriptor, declaration);
|
||||
|
||||
createPrimaryConstructorForObject(declaration, descriptor);
|
||||
trace.record(BindingContext.CLASS, declaration, descriptor);
|
||||
|
||||
c.getDeclaredClasses().put(declaration, descriptor);
|
||||
|
||||
return descriptor;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private ConstructorDescriptorImpl createPrimaryConstructorForObject(
|
||||
@Nullable JetClassOrObject object,
|
||||
@NotNull MutableClassDescriptor mutableClassDescriptor
|
||||
) {
|
||||
ConstructorDescriptorImpl constructorDescriptor = DescriptorResolver
|
||||
.createAndRecordPrimaryConstructorForObject(object, mutableClassDescriptor, trace);
|
||||
mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor);
|
||||
return constructorDescriptor;
|
||||
}
|
||||
|
||||
private void prepareForDeferredCall(
|
||||
@NotNull JetScope outerScope,
|
||||
@NotNull DeclarationDescriptor descriptorForDeferredResolve,
|
||||
@NotNull JetDeclarationContainer container
|
||||
) {
|
||||
forDeferredResolve.add(container);
|
||||
c.normalScope.put(container, outerScope);
|
||||
c.forDeferredResolver.put(container, descriptorForDeferredResolve);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -57,7 +57,7 @@ public class TypeResolver(
|
||||
return resolveType(TypeResolutionContext(scope, trace, checkBounds, false), typeReference)
|
||||
}
|
||||
|
||||
public fun resolveType(c: TypeResolutionContext, typeReference: JetTypeReference): JetType {
|
||||
private fun resolveType(c: TypeResolutionContext, typeReference: JetTypeReference): JetType {
|
||||
assert(!c.allowBareTypes, "Use resolvePossiblyBareType() when bare types are allowed")
|
||||
return resolvePossiblyBareType(c, typeReference).getActualType()
|
||||
}
|
||||
@@ -292,7 +292,7 @@ public class TypeResolver(
|
||||
val classifierDescriptor = qualifiedExpressionResolver.lookupDescriptorsForUserType(userType, scope, trace, true)
|
||||
.firstIsInstanceOrNull<ClassifierDescriptor>()
|
||||
if (classifierDescriptor != null) {
|
||||
ImportsResolver.reportPlatformClassMappedToKotlin(moduleDescriptor, trace, userType, classifierDescriptor)
|
||||
org.jetbrains.kotlin.resolve.PlatformTypesMappedToKotlinChecker.reportPlatformClassMappedToKotlin(moduleDescriptor, trace, userType, classifierDescriptor)
|
||||
}
|
||||
return classifierDescriptor
|
||||
}
|
||||
|
||||
@@ -49,14 +49,6 @@ import kotlin.platform.platformStatic
|
||||
|
||||
class VarianceChecker(private val trace: BindingTrace) {
|
||||
|
||||
fun process(c: TopDownAnalysisContext) {
|
||||
for (member in c.getMembers().values()) {
|
||||
recordPrivateToThisIfNeeded(trace, member)
|
||||
}
|
||||
|
||||
check(c)
|
||||
}
|
||||
|
||||
fun check(c: TopDownAnalysisContext) {
|
||||
checkClasses(c)
|
||||
checkMembers(c)
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve.lazy
|
||||
|
||||
import com.intellij.psi.PsiElement
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope
|
||||
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
|
||||
|
||||
public trait DeclarationScopeProvider {
|
||||
fun getResolutionScopeForDeclaration(elementOfDeclaration: PsiElement): JetScope
|
||||
fun getOuterDataFlowInfoForDeclaration(elementOfDeclaration: PsiElement): DataFlowInfo
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve.lazy;
|
||||
|
||||
import com.intellij.psi.PsiElement;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor;
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope;
|
||||
|
||||
import javax.inject.Inject;
|
||||
|
||||
public class DeclarationScopeProviderImpl implements DeclarationScopeProvider {
|
||||
|
||||
private final LazyDeclarationResolver lazyDeclarationResolver;
|
||||
|
||||
private FileScopeProvider fileScopeProvider;
|
||||
|
||||
@Inject
|
||||
public void setFileScopeProvider(@NotNull FileScopeProvider fileScopeProvider) {
|
||||
this.fileScopeProvider = fileScopeProvider;
|
||||
}
|
||||
|
||||
public DeclarationScopeProviderImpl(@NotNull LazyDeclarationResolver lazyDeclarationResolver) {
|
||||
this.lazyDeclarationResolver = lazyDeclarationResolver;
|
||||
}
|
||||
|
||||
@Override
|
||||
@NotNull
|
||||
public JetScope getResolutionScopeForDeclaration(@NotNull PsiElement elementOfDeclaration) {
|
||||
JetDeclaration jetDeclaration = JetStubbedPsiUtil.getPsiOrStubParent(elementOfDeclaration, JetDeclaration.class, false);
|
||||
|
||||
assert !(elementOfDeclaration instanceof JetDeclaration) || jetDeclaration == elementOfDeclaration :
|
||||
"For JetDeclaration element getParentOfType() should return itself.";
|
||||
assert jetDeclaration != null : "Should be contained inside declaration.";
|
||||
|
||||
JetDeclaration parentDeclaration = JetStubbedPsiUtil.getContainingDeclaration(jetDeclaration);
|
||||
|
||||
if (jetDeclaration instanceof JetPropertyAccessor) {
|
||||
parentDeclaration = JetStubbedPsiUtil.getContainingDeclaration(parentDeclaration, JetDeclaration.class);
|
||||
}
|
||||
|
||||
if (parentDeclaration == null) {
|
||||
return fileScopeProvider.getFileScope((JetFile) elementOfDeclaration.getContainingFile());
|
||||
}
|
||||
|
||||
if (parentDeclaration instanceof JetClassOrObject) {
|
||||
JetClassOrObject classOrObject = (JetClassOrObject) parentDeclaration;
|
||||
LazyClassDescriptor classDescriptor = (LazyClassDescriptor) lazyDeclarationResolver.getClassDescriptor(classOrObject);
|
||||
if (jetDeclaration instanceof JetClassInitializer || jetDeclaration instanceof JetProperty) {
|
||||
return classDescriptor.getScopeForInitializerResolution();
|
||||
}
|
||||
return classDescriptor.getScopeForMemberDeclarationResolution();
|
||||
}
|
||||
|
||||
if (parentDeclaration instanceof JetClassObject) {
|
||||
assert jetDeclaration instanceof JetObjectDeclaration : "Should be situation for getting scope for object in class [object {...}]";
|
||||
|
||||
JetClassObject classObject = (JetClassObject) parentDeclaration;
|
||||
LazyClassDescriptor classObjectDescriptor =
|
||||
(LazyClassDescriptor) lazyDeclarationResolver.getClassObjectDescriptor(classObject).getContainingDeclaration();
|
||||
|
||||
return classObjectDescriptor.getScopeForMemberDeclarationResolution();
|
||||
}
|
||||
|
||||
throw new IllegalStateException("Don't call this method for local declarations: " + jetDeclaration + "\n" +
|
||||
JetPsiUtil.getElementTextWithContext(jetDeclaration));
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public DataFlowInfo getOuterDataFlowInfoForDeclaration(@NotNull PsiElement elementOfDeclaration) {
|
||||
return DataFlowInfo.EMPTY;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve.lazy
|
||||
|
||||
import org.jetbrains.kotlin.psi.JetFile
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope
|
||||
|
||||
public trait FileScopeProvider {
|
||||
fun getFileScope(jetFile: JetFile): JetScope
|
||||
}
|
||||
|
||||
public object NoFileScopeProvider : FileScopeProvider {
|
||||
override fun getFileScope(jetFile: JetFile): JetScope {
|
||||
throw UnsupportedOperationException("Should not be called")
|
||||
}
|
||||
}
|
||||
@@ -17,35 +17,26 @@
|
||||
package org.jetbrains.kotlin.resolve.lazy;
|
||||
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.jetbrains.annotations.ReadOnly;
|
||||
import org.jetbrains.kotlin.descriptors.*;
|
||||
import org.jetbrains.kotlin.descriptors.ClassDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.name.FqName;
|
||||
import org.jetbrains.kotlin.psi.JetClassOrObject;
|
||||
import org.jetbrains.kotlin.psi.JetDeclaration;
|
||||
import org.jetbrains.kotlin.psi.JetScript;
|
||||
import org.jetbrains.kotlin.resolve.BindingContext;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor;
|
||||
|
||||
import java.util.Collection;
|
||||
|
||||
public interface KotlinCodeAnalyzer {
|
||||
@Nullable
|
||||
LazyPackageDescriptor getPackageFragment(@NotNull FqName fqName);
|
||||
public interface KotlinCodeAnalyzer extends TopLevelDescriptorProvider {
|
||||
|
||||
@NotNull
|
||||
ModuleDescriptor getModuleDescriptor();
|
||||
|
||||
@NotNull
|
||||
@ReadOnly
|
||||
Collection<ClassDescriptor> getTopLevelClassDescriptors(@NotNull FqName fqName);
|
||||
|
||||
@NotNull
|
||||
ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject);
|
||||
|
||||
@NotNull
|
||||
ScriptDescriptor getScriptDescriptor(@NotNull JetScript script);
|
||||
|
||||
@NotNull
|
||||
BindingContext getBindingContext();
|
||||
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve.lazy
|
||||
|
||||
import org.jetbrains.kotlin.storage.StorageManager
|
||||
import org.jetbrains.kotlin.resolve.BindingTrace
|
||||
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver
|
||||
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
|
||||
import org.jetbrains.kotlin.resolve.AnnotationResolver
|
||||
|
||||
public trait LazyClassContext {
|
||||
val scopeProvider: DeclarationScopeProvider
|
||||
|
||||
val storageManager: StorageManager
|
||||
val trace: BindingTrace
|
||||
val moduleDescriptor: ModuleDescriptor
|
||||
val descriptorResolver: DescriptorResolver
|
||||
val typeResolver: TypeResolver
|
||||
val declarationProviderFactory: DeclarationProviderFactory
|
||||
val annotationResolver: AnnotationResolver
|
||||
}
|
||||
@@ -0,0 +1,251 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve.lazy;
|
||||
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.util.PsiTreeUtil;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.context.GlobalContext;
|
||||
import org.jetbrains.kotlin.descriptors.*;
|
||||
import org.jetbrains.kotlin.name.FqName;
|
||||
import org.jetbrains.kotlin.name.Name;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
import org.jetbrains.kotlin.renderer.DescriptorRenderer;
|
||||
import org.jetbrains.kotlin.resolve.BindingContext;
|
||||
import org.jetbrains.kotlin.resolve.BindingTrace;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor;
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope;
|
||||
import org.jetbrains.kotlin.storage.LockBasedLazyResolveStorageManager;
|
||||
|
||||
import javax.inject.Inject;
|
||||
import java.util.List;
|
||||
|
||||
public class LazyDeclarationResolver {
|
||||
|
||||
private final BindingTrace trace;
|
||||
|
||||
protected DeclarationScopeProvider scopeProvider;
|
||||
private TopLevelDescriptorProvider topLevelDescriptorProvider;
|
||||
|
||||
@Inject
|
||||
public void setDeclarationScopeProvider(@NotNull DeclarationScopeProviderImpl scopeProvider) {
|
||||
this.scopeProvider = scopeProvider;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setTopLevelDescriptorProvider(@NotNull TopLevelDescriptorProvider topLevelDescriptorProvider) {
|
||||
this.topLevelDescriptorProvider = topLevelDescriptorProvider;
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public LazyDeclarationResolver(
|
||||
@NotNull GlobalContext globalContext,
|
||||
@NotNull BindingTrace delegationTrace
|
||||
) {
|
||||
LockBasedLazyResolveStorageManager lockBasedLazyResolveStorageManager =
|
||||
new LockBasedLazyResolveStorageManager(globalContext.getStorageManager());
|
||||
|
||||
this.trace = lockBasedLazyResolveStorageManager.createSafeTrace(delegationTrace);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject) {
|
||||
if (classOrObject instanceof JetObjectDeclaration) {
|
||||
JetObjectDeclaration objectDeclaration = (JetObjectDeclaration) classOrObject;
|
||||
JetClassObject classObjectElement = objectDeclaration.getClassObjectElement();
|
||||
if (classObjectElement != null) {
|
||||
return getClassObjectDescriptor(classObjectElement);
|
||||
}
|
||||
}
|
||||
JetScope resolutionScope = resolutionScopeToResolveDeclaration(classOrObject);
|
||||
|
||||
// Why not use the result here. Because it may be that there is a redeclaration:
|
||||
// class A {} class A { fun foo(): A<completion here>}
|
||||
// and if we find the class by name only, we may b-not get the right one.
|
||||
// This call is only needed to make sure the classes are written to trace
|
||||
ClassifierDescriptor scopeDescriptor = resolutionScope.getClassifier(classOrObject.getNameAsSafeName());
|
||||
DeclarationDescriptor descriptor = getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, classOrObject);
|
||||
|
||||
if (descriptor == null) {
|
||||
throw new IllegalArgumentException(
|
||||
String.format("Could not find a classifier for %s.\n" +
|
||||
"Found descriptor: %s (%s).\n",
|
||||
JetPsiUtil.getElementTextWithContext(classOrObject),
|
||||
scopeDescriptor != null ? DescriptorRenderer.DEBUG_TEXT.render(scopeDescriptor) : "null",
|
||||
scopeDescriptor != null ? (scopeDescriptor.getContainingDeclaration().getClass()) : null));
|
||||
}
|
||||
|
||||
return (ClassDescriptor) descriptor;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
/*package*/ LazyClassDescriptor getClassObjectDescriptor(@NotNull JetClassObject classObject) {
|
||||
JetClass aClass = JetStubbedPsiUtil.getContainingDeclaration(classObject, JetClass.class);
|
||||
|
||||
LazyClassDescriptor parentClassDescriptor;
|
||||
|
||||
if (aClass != null) {
|
||||
parentClassDescriptor = (LazyClassDescriptor) getClassDescriptor(aClass);
|
||||
}
|
||||
else {
|
||||
// Class object in object is an error but we want to find descriptors even for this case
|
||||
JetObjectDeclaration objectDeclaration = PsiTreeUtil.getParentOfType(classObject, JetObjectDeclaration.class);
|
||||
assert objectDeclaration != null : String.format("Class object %s can be in class or object in file %s", classObject, classObject.getContainingFile().getText());
|
||||
parentClassDescriptor = (LazyClassDescriptor) getClassDescriptor(objectDeclaration);
|
||||
}
|
||||
|
||||
// Activate resolution and writing to trace
|
||||
parentClassDescriptor.getClassObjectDescriptor();
|
||||
parentClassDescriptor.getDescriptorsForExtraClassObjects();
|
||||
DeclarationDescriptor classObjectDescriptor = getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, classObject.getObjectDeclaration());
|
||||
assert classObjectDescriptor != null : "No descriptor found for " + JetPsiUtil.getElementTextWithContext(classObject);
|
||||
|
||||
return (LazyClassDescriptor) classObjectDescriptor;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private BindingContext getBindingContext() {
|
||||
return trace.getBindingContext();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public DeclarationDescriptor resolveToDescriptor(@NotNull JetDeclaration declaration) {
|
||||
DeclarationDescriptor result = declaration.accept(new JetVisitor<DeclarationDescriptor, Void>() {
|
||||
@Override
|
||||
public DeclarationDescriptor visitClass(@NotNull JetClass klass, Void data) {
|
||||
return getClassDescriptor(klass);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, Void data) {
|
||||
PsiElement parent = declaration.getParent();
|
||||
if (parent instanceof JetClassObject) {
|
||||
JetClassObject jetClassObject = (JetClassObject) parent;
|
||||
return resolveToDescriptor(jetClassObject);
|
||||
}
|
||||
return getClassDescriptor(declaration);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitClassObject(@NotNull JetClassObject classObject, Void data) {
|
||||
return getClassObjectDescriptor(classObject);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitTypeParameter(@NotNull JetTypeParameter parameter, Void data) {
|
||||
JetTypeParameterListOwner ownerElement = PsiTreeUtil.getParentOfType(parameter, JetTypeParameterListOwner.class);
|
||||
DeclarationDescriptor ownerDescriptor = resolveToDescriptor(ownerElement);
|
||||
|
||||
List<TypeParameterDescriptor> typeParameters;
|
||||
if (ownerDescriptor instanceof CallableDescriptor) {
|
||||
CallableDescriptor callableDescriptor = (CallableDescriptor) ownerDescriptor;
|
||||
typeParameters = callableDescriptor.getTypeParameters();
|
||||
}
|
||||
else if (ownerDescriptor instanceof ClassDescriptor) {
|
||||
ClassDescriptor classDescriptor = (ClassDescriptor) ownerDescriptor;
|
||||
typeParameters = classDescriptor.getTypeConstructor().getParameters();
|
||||
}
|
||||
else {
|
||||
throw new IllegalStateException("Unknown owner kind for a type parameter: " + ownerDescriptor);
|
||||
}
|
||||
|
||||
Name name = parameter.getNameAsSafeName();
|
||||
for (TypeParameterDescriptor typeParameterDescriptor : typeParameters) {
|
||||
if (typeParameterDescriptor.getName().equals(name)) {
|
||||
return typeParameterDescriptor;
|
||||
}
|
||||
}
|
||||
|
||||
throw new IllegalStateException("Type parameter " + name + " not found for " + ownerDescriptor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitNamedFunction(@NotNull JetNamedFunction function, Void data) {
|
||||
JetScope scopeForDeclaration = resolutionScopeToResolveDeclaration(function);
|
||||
scopeForDeclaration.getFunctions(function.getNameAsSafeName());
|
||||
return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, function);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitParameter(@NotNull JetParameter parameter, Void data) {
|
||||
PsiElement grandFather = parameter.getParent().getParent();
|
||||
if (grandFather instanceof JetClass) {
|
||||
JetClass jetClass = (JetClass) grandFather;
|
||||
// This is a primary constructor parameter
|
||||
ClassDescriptor classDescriptor = getClassDescriptor(jetClass);
|
||||
if (parameter.hasValOrVarNode()) {
|
||||
classDescriptor.getDefaultType().getMemberScope().getProperties(parameter.getNameAsSafeName());
|
||||
return getBindingContext().get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter);
|
||||
}
|
||||
else {
|
||||
ConstructorDescriptor constructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
|
||||
assert constructor != null: "There are constructor parameters found, so a constructor should also exist";
|
||||
constructor.getValueParameters();
|
||||
return getBindingContext().get(BindingContext.VALUE_PARAMETER, parameter);
|
||||
}
|
||||
}
|
||||
else if (grandFather instanceof JetNamedFunction) {
|
||||
FunctionDescriptor function = (FunctionDescriptor) visitNamedFunction((JetNamedFunction) grandFather, data);
|
||||
function.getValueParameters();
|
||||
return getBindingContext().get(BindingContext.VALUE_PARAMETER, parameter);
|
||||
}
|
||||
else {
|
||||
//TODO: support parameters in accessors and other places(?)
|
||||
return super.visitParameter(parameter, data);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitProperty(@NotNull JetProperty property, Void data) {
|
||||
JetScope scopeForDeclaration = resolutionScopeToResolveDeclaration(property);
|
||||
scopeForDeclaration.getProperties(property.getNameAsSafeName());
|
||||
return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, property);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitScript(@NotNull JetScript script, Void data) {
|
||||
return topLevelDescriptorProvider.getScriptDescriptor(script);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitJetElement(@NotNull JetElement element, Void data) {
|
||||
throw new IllegalArgumentException("Unsupported declaration type: " + element + " " +
|
||||
JetPsiUtil.getElementTextWithContext(element));
|
||||
}
|
||||
}, null);
|
||||
if (result == null) {
|
||||
throw new IllegalStateException("No descriptor resolved for " + declaration + ":\n" +
|
||||
JetPsiUtil.getElementTextWithContext(declaration));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
/*package*/ JetScope resolutionScopeToResolveDeclaration(@NotNull JetDeclaration declaration) {
|
||||
boolean isTopLevel = JetStubbedPsiUtil.getContainingDeclaration(declaration) == null;
|
||||
if (isTopLevel) { // for top level declarations we search directly in package because of possible conflicts with imports
|
||||
FqName fqName = ((JetFile) declaration.getContainingFile()).getPackageFqName();
|
||||
LazyPackageDescriptor packageDescriptor = topLevelDescriptorProvider.getPackageFragment(fqName);
|
||||
assert packageDescriptor != null;
|
||||
return packageDescriptor.getMemberScope();
|
||||
}
|
||||
else {
|
||||
return scopeProvider.getResolutionScopeForDeclaration(declaration);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.psi.JetImportDirective
|
||||
import org.jetbrains.kotlin.psi.debugText.*
|
||||
import org.jetbrains.kotlin.resolve.BindingTrace
|
||||
import org.jetbrains.kotlin.resolve.Importer
|
||||
import org.jetbrains.kotlin.resolve.ImportsResolver
|
||||
import org.jetbrains.kotlin.resolve.JetModuleUtil
|
||||
import org.jetbrains.kotlin.name.Name
|
||||
import org.jetbrains.kotlin.resolve.scopes.*
|
||||
@@ -35,6 +34,8 @@ import kotlin.properties.Delegates
|
||||
import com.google.common.collect.ImmutableListMultimap
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScopeSelectorUtil.ScopeByNameSelector
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScopeSelectorUtil.ScopeByNameMultiSelector
|
||||
import org.jetbrains.kotlin.psi.JetPsiUtil
|
||||
import org.jetbrains.kotlin.diagnostics.Errors
|
||||
|
||||
trait IndexedImports {
|
||||
val imports: List<JetImportDirective>
|
||||
@@ -108,7 +109,7 @@ class LazyImportResolver(
|
||||
importer, traceForImportResolve, mode)
|
||||
importer.doImport(directiveImportScope)
|
||||
if (mode == LookupMode.EVERYTHING) {
|
||||
ImportsResolver.checkPlatformTypesMappedToKotlin(packageView.getModule(), traceForImportResolve, directive, descriptors)
|
||||
org.jetbrains.kotlin.resolve.PlatformTypesMappedToKotlinChecker.checkPlatformTypesMappedToKotlin(packageView.getModule(), traceForImportResolve, directive, descriptors)
|
||||
}
|
||||
}
|
||||
finally {
|
||||
@@ -135,10 +136,40 @@ class LazyImportResolver(
|
||||
val status = importedScopesProvider(importDirective).importResolveStatus
|
||||
if (status != null && !status.descriptors.isEmpty()) {
|
||||
val fileScope = resolveSession.getScopeProvider().getFileScope(importDirective.getContainingJetFile())
|
||||
ImportsResolver.reportConflictingImport(importDirective, fileScope, status.descriptors, traceForImportResolve)
|
||||
reportConflictingImport(importDirective, fileScope, status.descriptors, traceForImportResolve)
|
||||
}
|
||||
}
|
||||
|
||||
private fun reportConflictingImport(
|
||||
importDirective: JetImportDirective,
|
||||
fileScope: JetScope,
|
||||
resolvedTo: Collection<DeclarationDescriptor>?,
|
||||
trace: BindingTrace
|
||||
) {
|
||||
|
||||
val importedReference = importDirective.getImportedReference()
|
||||
if (importedReference == null || resolvedTo == null) return
|
||||
|
||||
val aliasName = JetPsiUtil.getAliasName(importDirective)
|
||||
if (aliasName == null) return
|
||||
|
||||
if (resolvedTo.size() != 1) return
|
||||
|
||||
when (resolvedTo.single()) {
|
||||
is ClassDescriptor -> {
|
||||
if (fileScope.getClassifier(aliasName) == null) {
|
||||
trace.report(Errors.CONFLICTING_IMPORT.on(importedReference, aliasName.asString()))
|
||||
}
|
||||
}
|
||||
is PackageViewDescriptor -> {
|
||||
if (fileScope.getPackage(aliasName) == null) {
|
||||
trace.report(Errors.CONFLICTING_IMPORT.on(importedReference, aliasName.asString()))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public fun <D : DeclarationDescriptor> selectSingleFromImports(
|
||||
name: Name,
|
||||
lookupMode: LookupMode,
|
||||
|
||||
@@ -18,8 +18,6 @@ package org.jetbrains.kotlin.resolve.lazy;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.util.PsiTreeUtil;
|
||||
import com.intellij.util.Function;
|
||||
import com.intellij.util.containers.ContainerUtil;
|
||||
import kotlin.Function1;
|
||||
@@ -33,13 +31,15 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
|
||||
import org.jetbrains.kotlin.name.FqName;
|
||||
import org.jetbrains.kotlin.name.Name;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
import org.jetbrains.kotlin.renderer.DescriptorRenderer;
|
||||
import org.jetbrains.kotlin.resolve.*;
|
||||
import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo;
|
||||
import org.jetbrains.kotlin.resolve.lazy.data.JetScriptInfo;
|
||||
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
|
||||
import org.jetbrains.kotlin.resolve.lazy.declarations.PackageMemberDeclarationProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.*;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotations;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationsContextImpl;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyScriptDescriptor;
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope;
|
||||
import org.jetbrains.kotlin.storage.*;
|
||||
|
||||
@@ -48,7 +48,7 @@ import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
|
||||
private final LazyResolveStorageManager storageManager;
|
||||
private final ExceptionTracker exceptionTracker;
|
||||
|
||||
@@ -73,6 +73,7 @@ public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
private TypeResolver typeResolver;
|
||||
private QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private ScriptBodyResolver scriptBodyResolver;
|
||||
private LazyDeclarationResolver lazyDeclarationResolver;
|
||||
|
||||
@Inject
|
||||
public void setJetImportFactory(JetImportsFactory jetImportFactory) {
|
||||
@@ -109,6 +110,11 @@ public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
this.scriptBodyResolver = scriptBodyResolver;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setLazyDeclarationResolver(LazyDeclarationResolver lazyDeclarationResolver) {
|
||||
this.lazyDeclarationResolver = lazyDeclarationResolver;
|
||||
}
|
||||
|
||||
// Only calls from injectors expected
|
||||
@Deprecated
|
||||
public ResolveSession(
|
||||
@@ -126,13 +132,14 @@ public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
this.trace = lockBasedLazyResolveStorageManager.createSafeTrace(delegationTrace);
|
||||
this.module = rootDescriptor;
|
||||
|
||||
this.packages = storageManager.createMemoizedFunctionWithNullableValues(new MemoizedFunctionToNullable<FqName, LazyPackageDescriptor>() {
|
||||
@Nullable
|
||||
@Override
|
||||
public LazyPackageDescriptor invoke(FqName fqName) {
|
||||
return createPackage(fqName);
|
||||
}
|
||||
});
|
||||
this.packages =
|
||||
storageManager.createMemoizedFunctionWithNullableValues(new MemoizedFunctionToNullable<FqName, LazyPackageDescriptor>() {
|
||||
@Nullable
|
||||
@Override
|
||||
public LazyPackageDescriptor invoke(FqName fqName) {
|
||||
return createPackage(fqName);
|
||||
}
|
||||
});
|
||||
|
||||
this.declarationProviderFactory = declarationProviderFactory;
|
||||
|
||||
@@ -146,7 +153,8 @@ public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
@NotNull
|
||||
@Override
|
||||
public Collection<FqName> getSubPackagesOf(
|
||||
@NotNull FqName fqName, @NotNull Function1<? super Name, ? extends Boolean> nameFilter) {
|
||||
@NotNull FqName fqName, @NotNull Function1<? super Name, ? extends Boolean> nameFilter
|
||||
) {
|
||||
LazyPackageDescriptor packageDescriptor = getPackageFragment(fqName);
|
||||
if (packageDescriptor == null) {
|
||||
return Collections.emptyList();
|
||||
@@ -221,13 +229,12 @@ public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
}
|
||||
|
||||
@NotNull
|
||||
//@Override
|
||||
@Override
|
||||
public LazyResolveStorageManager getStorageManager() {
|
||||
return storageManager;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
//@Override
|
||||
public ExceptionTracker getExceptionTracker() {
|
||||
return exceptionTracker;
|
||||
}
|
||||
@@ -260,37 +267,12 @@ public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
@Override
|
||||
@NotNull
|
||||
public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject) {
|
||||
if (classOrObject instanceof JetObjectDeclaration) {
|
||||
JetObjectDeclaration objectDeclaration = (JetObjectDeclaration) classOrObject;
|
||||
JetClassObject classObjectElement = objectDeclaration.getClassObjectElement();
|
||||
if (classObjectElement != null) {
|
||||
return getClassObjectDescriptor(classObjectElement);
|
||||
}
|
||||
}
|
||||
JetScope resolutionScope = resolutionScopeToResolveDeclaration(classOrObject);
|
||||
|
||||
// Why not use the result here. Because it may be that there is a redeclaration:
|
||||
// class A {} class A { fun foo(): A<completion here>}
|
||||
// and if we find the class by name only, we may b-not get the right one.
|
||||
// This call is only needed to make sure the classes are written to trace
|
||||
ClassifierDescriptor scopeDescriptor = resolutionScope.getClassifier(classOrObject.getNameAsSafeName());
|
||||
DeclarationDescriptor descriptor = getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, classOrObject);
|
||||
|
||||
if (descriptor == null) {
|
||||
throw new IllegalArgumentException(
|
||||
String.format("Could not find a classifier for %s.\n" +
|
||||
"Found descriptor: %s (%s).\n",
|
||||
JetPsiUtil.getElementTextWithContext(classOrObject),
|
||||
scopeDescriptor != null ? DescriptorRenderer.DEBUG_TEXT.render(scopeDescriptor) : "null",
|
||||
scopeDescriptor != null ? (scopeDescriptor.getContainingDeclaration().getClass()) : null));
|
||||
}
|
||||
|
||||
return (ClassDescriptor) descriptor;
|
||||
return lazyDeclarationResolver.getClassDescriptor(classOrObject);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getClassDescriptorForScript(@NotNull JetScript script) {
|
||||
JetScope resolutionScope = resolutionScopeToResolveDeclaration(script);
|
||||
JetScope resolutionScope = lazyDeclarationResolver.resolutionScopeToResolveDeclaration(script);
|
||||
FqName fqName = ScriptNameUtil.classNameForScript(script);
|
||||
ClassifierDescriptor classifier = resolutionScope.getClassifier(fqName.shortName());
|
||||
assert classifier != null : "No descriptor for " + fqName + " in file " + script.getContainingFile();
|
||||
@@ -303,42 +285,19 @@ public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
return scriptDescriptors.invoke(script);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
/*package*/ LazyClassDescriptor getClassObjectDescriptor(@NotNull JetClassObject classObject) {
|
||||
JetClass aClass = JetStubbedPsiUtil.getContainingDeclaration(classObject, JetClass.class);
|
||||
|
||||
LazyClassDescriptor parentClassDescriptor;
|
||||
|
||||
if (aClass != null) {
|
||||
parentClassDescriptor = (LazyClassDescriptor) getClassDescriptor(aClass);
|
||||
}
|
||||
else {
|
||||
// Class object in object is an error but we want to find descriptors even for this case
|
||||
JetObjectDeclaration objectDeclaration = PsiTreeUtil.getParentOfType(classObject, JetObjectDeclaration.class);
|
||||
assert objectDeclaration != null : String.format("Class object %s can be in class or object in file %s", classObject, classObject.getContainingFile().getText());
|
||||
parentClassDescriptor = (LazyClassDescriptor) getClassDescriptor(objectDeclaration);
|
||||
}
|
||||
|
||||
// Activate resolution and writing to trace
|
||||
parentClassDescriptor.getClassObjectDescriptor();
|
||||
parentClassDescriptor.getDescriptorsForExtraClassObjects();
|
||||
DeclarationDescriptor classObjectDescriptor = getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, classObject.getObjectDeclaration());
|
||||
assert classObjectDescriptor != null : "No descriptor found for " + JetPsiUtil.getElementTextWithContext(classObject);
|
||||
|
||||
return (LazyClassDescriptor) classObjectDescriptor;
|
||||
}
|
||||
|
||||
@Override
|
||||
@NotNull
|
||||
public BindingContext getBindingContext() {
|
||||
return trace.getBindingContext();
|
||||
}
|
||||
|
||||
@Override
|
||||
@NotNull
|
||||
public BindingTrace getTrace() {
|
||||
return trace;
|
||||
}
|
||||
|
||||
@Override
|
||||
@NotNull
|
||||
public DeclarationProviderFactory getDeclarationProviderFactory() {
|
||||
return declarationProviderFactory;
|
||||
@@ -347,114 +306,7 @@ public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
@Override
|
||||
@NotNull
|
||||
public DeclarationDescriptor resolveToDescriptor(@NotNull JetDeclaration declaration) {
|
||||
DeclarationDescriptor result = declaration.accept(new JetVisitor<DeclarationDescriptor, Void>() {
|
||||
@Override
|
||||
public DeclarationDescriptor visitClass(@NotNull JetClass klass, Void data) {
|
||||
return getClassDescriptor(klass);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, Void data) {
|
||||
PsiElement parent = declaration.getParent();
|
||||
if (parent instanceof JetClassObject) {
|
||||
JetClassObject jetClassObject = (JetClassObject) parent;
|
||||
return resolveToDescriptor(jetClassObject);
|
||||
}
|
||||
return getClassDescriptor(declaration);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitClassObject(@NotNull JetClassObject classObject, Void data) {
|
||||
return getClassObjectDescriptor(classObject);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitTypeParameter(@NotNull JetTypeParameter parameter, Void data) {
|
||||
JetTypeParameterListOwner ownerElement = PsiTreeUtil.getParentOfType(parameter, JetTypeParameterListOwner.class);
|
||||
DeclarationDescriptor ownerDescriptor = resolveToDescriptor(ownerElement);
|
||||
|
||||
List<TypeParameterDescriptor> typeParameters;
|
||||
if (ownerDescriptor instanceof CallableDescriptor) {
|
||||
CallableDescriptor callableDescriptor = (CallableDescriptor) ownerDescriptor;
|
||||
typeParameters = callableDescriptor.getTypeParameters();
|
||||
}
|
||||
else if (ownerDescriptor instanceof ClassDescriptor) {
|
||||
ClassDescriptor classDescriptor = (ClassDescriptor) ownerDescriptor;
|
||||
typeParameters = classDescriptor.getTypeConstructor().getParameters();
|
||||
}
|
||||
else {
|
||||
throw new IllegalStateException("Unknown owner kind for a type parameter: " + ownerDescriptor);
|
||||
}
|
||||
|
||||
Name name = parameter.getNameAsSafeName();
|
||||
for (TypeParameterDescriptor typeParameterDescriptor : typeParameters) {
|
||||
if (typeParameterDescriptor.getName().equals(name)) {
|
||||
return typeParameterDescriptor;
|
||||
}
|
||||
}
|
||||
|
||||
throw new IllegalStateException("Type parameter " + name + " not found for " + ownerDescriptor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitNamedFunction(@NotNull JetNamedFunction function, Void data) {
|
||||
JetScope scopeForDeclaration = resolutionScopeToResolveDeclaration(function);
|
||||
scopeForDeclaration.getFunctions(function.getNameAsSafeName());
|
||||
return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, function);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitParameter(@NotNull JetParameter parameter, Void data) {
|
||||
PsiElement grandFather = parameter.getParent().getParent();
|
||||
if (grandFather instanceof JetClass) {
|
||||
JetClass jetClass = (JetClass) grandFather;
|
||||
// This is a primary constructor parameter
|
||||
ClassDescriptor classDescriptor = getClassDescriptor(jetClass);
|
||||
if (parameter.hasValOrVarNode()) {
|
||||
classDescriptor.getDefaultType().getMemberScope().getProperties(parameter.getNameAsSafeName());
|
||||
return getBindingContext().get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter);
|
||||
}
|
||||
else {
|
||||
ConstructorDescriptor constructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
|
||||
assert constructor != null: "There are constructor parameters found, so a constructor should also exist";
|
||||
constructor.getValueParameters();
|
||||
return getBindingContext().get(BindingContext.VALUE_PARAMETER, parameter);
|
||||
}
|
||||
}
|
||||
else if (grandFather instanceof JetNamedFunction) {
|
||||
FunctionDescriptor function = (FunctionDescriptor) visitNamedFunction((JetNamedFunction) grandFather, data);
|
||||
function.getValueParameters();
|
||||
return getBindingContext().get(BindingContext.VALUE_PARAMETER, parameter);
|
||||
}
|
||||
else {
|
||||
//TODO: support parameters in accessors and other places(?)
|
||||
return super.visitParameter(parameter, data);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitProperty(@NotNull JetProperty property, Void data) {
|
||||
JetScope scopeForDeclaration = resolutionScopeToResolveDeclaration(property);
|
||||
scopeForDeclaration.getProperties(property.getNameAsSafeName());
|
||||
return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, property);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitScript(@NotNull JetScript script, Void data) {
|
||||
return scriptDescriptors.invoke(script);
|
||||
}
|
||||
|
||||
@Override
|
||||
public DeclarationDescriptor visitJetElement(@NotNull JetElement element, Void data) {
|
||||
throw new IllegalArgumentException("Unsupported declaration type: " + element + " " +
|
||||
JetPsiUtil.getElementTextWithContext(element));
|
||||
}
|
||||
}, null);
|
||||
if (result == null) {
|
||||
throw new IllegalStateException("No descriptor resolved for " + declaration + ":\n" +
|
||||
JetPsiUtil.getElementTextWithContext(declaration));
|
||||
}
|
||||
return result;
|
||||
return lazyDeclarationResolver.resolveToDescriptor(declaration);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@@ -507,16 +359,19 @@ public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
return jetImportFactory;
|
||||
}
|
||||
|
||||
@Override
|
||||
@NotNull
|
||||
public AnnotationResolver getAnnotationResolver() {
|
||||
return annotationResolve;
|
||||
}
|
||||
|
||||
@Override
|
||||
@NotNull
|
||||
public DescriptorResolver getDescriptorResolver() {
|
||||
return descriptorResolver;
|
||||
}
|
||||
|
||||
@Override
|
||||
@NotNull
|
||||
public TypeResolver getTypeResolver() {
|
||||
return typeResolver;
|
||||
@@ -526,18 +381,4 @@ public class ResolveSession implements KotlinCodeAnalyzer {
|
||||
public QualifiedExpressionResolver getQualifiedExpressionResolver() {
|
||||
return qualifiedExpressionResolver;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private JetScope resolutionScopeToResolveDeclaration(@NotNull JetDeclaration declaration) {
|
||||
boolean isTopLevel = JetStubbedPsiUtil.getContainingDeclaration(declaration) == null;
|
||||
if (isTopLevel) { // for top level declarations we search directly in package because of possible conflicts with imports
|
||||
FqName fqName = ((JetFile) declaration.getContainingFile()).getPackageFqName();
|
||||
LazyPackageDescriptor packageDescriptor = getPackageFragment(fqName);
|
||||
assert packageDescriptor != null;
|
||||
return packageDescriptor.getMemberScope();
|
||||
}
|
||||
else {
|
||||
return getScopeProvider().getResolutionScopeForDeclaration(declaration);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -22,10 +22,12 @@ import kotlin.Function1;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
|
||||
import org.jetbrains.kotlin.name.FqName;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
import org.jetbrains.kotlin.psi.JetFile;
|
||||
import org.jetbrains.kotlin.psi.JetImportDirective;
|
||||
import org.jetbrains.kotlin.psi.JetImportsFactory;
|
||||
import org.jetbrains.kotlin.resolve.ImportPath;
|
||||
import org.jetbrains.kotlin.resolve.TemporaryBindingTrace;
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor;
|
||||
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope;
|
||||
import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull;
|
||||
import org.jetbrains.kotlin.storage.NotNullLazyValue;
|
||||
@@ -35,7 +37,8 @@ import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
public class ScopeProvider {
|
||||
public class ScopeProvider implements DeclarationScopeProvider, FileScopeProvider {
|
||||
|
||||
public static class AdditionalFileScopeProvider {
|
||||
@NotNull
|
||||
public List<JetScope> scopes(@NotNull JetFile file) {
|
||||
@@ -49,14 +52,19 @@ public class ScopeProvider {
|
||||
|
||||
private final MemoizedFunctionToNotNull<JetFile, LazyFileScope> fileScopes;
|
||||
|
||||
@SuppressWarnings("ConstantConditions") @NotNull
|
||||
private AdditionalFileScopeProvider additionalFileScopeProvider = null;
|
||||
private AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private DeclarationScopeProvider declarationScopeProvider;
|
||||
|
||||
@Inject
|
||||
public void setAdditionalFileScopesProvider(@NotNull AdditionalFileScopeProvider additionalFileScopeProvider) {
|
||||
this.additionalFileScopeProvider = additionalFileScopeProvider;
|
||||
}
|
||||
|
||||
@Inject
|
||||
public void setDeclarationScopeProvider(@NotNull DeclarationScopeProviderImpl declarationScopeProvider) {
|
||||
this.declarationScopeProvider = declarationScopeProvider;
|
||||
}
|
||||
|
||||
public ScopeProvider(@NotNull final ResolveSession resolveSession) {
|
||||
this.resolveSession = resolveSession;
|
||||
|
||||
@@ -84,6 +92,7 @@ public class ScopeProvider {
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
@NotNull
|
||||
public LazyFileScope getFileScope(@NotNull JetFile file) {
|
||||
return fileScopes.invoke(file);
|
||||
@@ -102,43 +111,14 @@ public class ScopeProvider {
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public JetScope getResolutionScopeForDeclaration(@NotNull PsiElement elementOfDeclaration) {
|
||||
JetDeclaration jetDeclaration = JetStubbedPsiUtil.getPsiOrStubParent(elementOfDeclaration, JetDeclaration.class, false);
|
||||
return declarationScopeProvider.getResolutionScopeForDeclaration(elementOfDeclaration);
|
||||
}
|
||||
|
||||
assert !(elementOfDeclaration instanceof JetDeclaration) || jetDeclaration == elementOfDeclaration :
|
||||
"For JetDeclaration element getParentOfType() should return itself.";
|
||||
assert jetDeclaration != null : "Should be contained inside declaration.";
|
||||
|
||||
JetDeclaration parentDeclaration = JetStubbedPsiUtil.getContainingDeclaration(jetDeclaration);
|
||||
|
||||
if (jetDeclaration instanceof JetPropertyAccessor) {
|
||||
parentDeclaration = JetStubbedPsiUtil.getContainingDeclaration(parentDeclaration, JetDeclaration.class);
|
||||
}
|
||||
|
||||
if (parentDeclaration == null) {
|
||||
return getFileScope((JetFile) elementOfDeclaration.getContainingFile());
|
||||
}
|
||||
|
||||
if (parentDeclaration instanceof JetClassOrObject) {
|
||||
JetClassOrObject classOrObject = (JetClassOrObject) parentDeclaration;
|
||||
LazyClassDescriptor classDescriptor = (LazyClassDescriptor) resolveSession.getClassDescriptor(classOrObject);
|
||||
if (jetDeclaration instanceof JetClassInitializer || jetDeclaration instanceof JetProperty) {
|
||||
return classDescriptor.getScopeForInitializerResolution();
|
||||
}
|
||||
return classDescriptor.getScopeForMemberDeclarationResolution();
|
||||
}
|
||||
|
||||
if (parentDeclaration instanceof JetClassObject) {
|
||||
assert jetDeclaration instanceof JetObjectDeclaration : "Should be situation for getting scope for object in class [object {...}]";
|
||||
|
||||
JetClassObject classObject = (JetClassObject) parentDeclaration;
|
||||
LazyClassDescriptor classObjectDescriptor =
|
||||
(LazyClassDescriptor) resolveSession.getClassObjectDescriptor(classObject).getContainingDeclaration();
|
||||
|
||||
return classObjectDescriptor.getScopeForMemberDeclarationResolution();
|
||||
}
|
||||
|
||||
throw new IllegalStateException("Don't call this method for local declarations: " + jetDeclaration + "\n" +
|
||||
JetPsiUtil.getElementTextWithContext(jetDeclaration));
|
||||
@NotNull
|
||||
@Override
|
||||
public DataFlowInfo getOuterDataFlowInfoForDeclaration(@NotNull PsiElement elementOfDeclaration) {
|
||||
return declarationScopeProvider.getOuterDataFlowInfoForDeclaration(elementOfDeclaration);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.resolve.lazy
|
||||
|
||||
import org.jetbrains.kotlin.descriptors.ClassDescriptor
|
||||
import org.jetbrains.kotlin.descriptors.ScriptDescriptor
|
||||
import org.jetbrains.kotlin.name.FqName
|
||||
import org.jetbrains.kotlin.psi.JetScript
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor
|
||||
|
||||
public trait TopLevelDescriptorProvider {
|
||||
fun getPackageFragment(fqName: FqName): LazyPackageDescriptor?
|
||||
|
||||
fun getScriptDescriptor(script: JetScript): ScriptDescriptor
|
||||
|
||||
fun getTopLevelClassDescriptors(fqName: FqName): Collection<ClassDescriptor>
|
||||
}
|
||||
|
||||
public object NoTopLevelDescriptorProvider : TopLevelDescriptorProvider {
|
||||
private fun shouldNotBeCalled(): Nothing = throw UnsupportedOperationException("Should not be called")
|
||||
|
||||
override fun getPackageFragment(fqName: FqName): LazyPackageDescriptor? {
|
||||
shouldNotBeCalled()
|
||||
}
|
||||
|
||||
override fun getScriptDescriptor(script: JetScript): ScriptDescriptor {
|
||||
shouldNotBeCalled()
|
||||
}
|
||||
|
||||
override fun getTopLevelClassDescriptors(fqName: FqName): Collection<ClassDescriptor> {
|
||||
shouldNotBeCalled()
|
||||
}
|
||||
}
|
||||
@@ -33,7 +33,9 @@ public class JetObjectInfo extends JetClassOrObjectInfo<JetObjectDeclaration> {
|
||||
|
||||
protected JetObjectInfo(@NotNull JetObjectDeclaration element) {
|
||||
super(element);
|
||||
this.kind = element.isClassObject() ? ClassKind.CLASS_OBJECT : ClassKind.OBJECT;
|
||||
this.kind = element.isObjectLiteral()
|
||||
? ClassKind.CLASS
|
||||
: (element.isClassObject() ? ClassKind.CLASS_OBJECT : ClassKind.OBJECT);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -22,8 +22,6 @@ import org.jetbrains.kotlin.psi.*
|
||||
import org.jetbrains.kotlin.resolve.AnnotationResolver
|
||||
import org.jetbrains.kotlin.resolve.BindingTrace
|
||||
import org.jetbrains.kotlin.resolve.ScriptNameUtil
|
||||
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
|
||||
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
|
||||
import org.jetbrains.kotlin.resolve.lazy.data.JetScriptInfo
|
||||
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProvider
|
||||
import org.jetbrains.kotlin.name.Name
|
||||
@@ -35,14 +33,15 @@ import java.util.*
|
||||
import org.jetbrains.kotlin.storage.StorageManager
|
||||
import org.jetbrains.kotlin.utils.toReadOnlyList
|
||||
import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
|
||||
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
|
||||
|
||||
public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : DeclarationProvider> protected(
|
||||
protected val resolveSession: ResolveSession,
|
||||
protected val c: org.jetbrains.kotlin.resolve.lazy.LazyClassContext,
|
||||
protected val declarationProvider: DP,
|
||||
protected val thisDescriptor: D,
|
||||
protected val trace: BindingTrace) : JetScope {
|
||||
|
||||
protected val storageManager: StorageManager = resolveSession.getStorageManager()
|
||||
protected val storageManager: StorageManager = c.storageManager
|
||||
private val classDescriptors: MemoizedFunctionToNotNull<Name, List<ClassDescriptor>> = storageManager.createMemoizedFunction { resolveClassDescriptor(it) }
|
||||
private val functionDescriptors: MemoizedFunctionToNotNull<Name, Collection<FunctionDescriptor>> = storageManager.createMemoizedFunction { doGetFunctions(it) }
|
||||
private val propertyDescriptors: MemoizedFunctionToNotNull<Name, Collection<VariableDescriptor>> = storageManager.createMemoizedFunction { doGetProperties(it) }
|
||||
@@ -51,9 +50,9 @@ public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : De
|
||||
return declarationProvider.getClassOrObjectDeclarations(name).map {
|
||||
// SCRIPT: Creating a script class
|
||||
if (it is JetScriptInfo)
|
||||
LazyScriptClassDescriptor(resolveSession, thisDescriptor, name, it)
|
||||
LazyScriptClassDescriptor(c as ResolveSession, thisDescriptor, name, it)
|
||||
else
|
||||
LazyClassDescriptor(resolveSession, thisDescriptor, name, it)
|
||||
LazyClassDescriptor(c, thisDescriptor, name, it)
|
||||
}.toReadOnlyList()
|
||||
}
|
||||
|
||||
@@ -69,14 +68,12 @@ public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : De
|
||||
val declarations = declarationProvider.getFunctionDeclarations(name)
|
||||
for (functionDeclaration in declarations) {
|
||||
val resolutionScope = getScopeForMemberDeclarationResolution(functionDeclaration)
|
||||
result.add(resolveSession.getDescriptorResolver().resolveFunctionDescriptorWithAnnotationArguments(
|
||||
result.add(c.descriptorResolver.resolveFunctionDescriptorWithAnnotationArguments(
|
||||
thisDescriptor,
|
||||
resolutionScope,
|
||||
functionDeclaration,
|
||||
trace,
|
||||
// this relies on the assumption that a lazily resolved declaration is not a local one,
|
||||
// thus doesn't have a surrounding data flow
|
||||
DataFlowInfo.EMPTY))
|
||||
c.scopeProvider.getOuterDataFlowInfoForDeclaration(functionDeclaration)))
|
||||
}
|
||||
|
||||
getNonDeclaredFunctions(name, result)
|
||||
@@ -96,14 +93,12 @@ public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : De
|
||||
val declarations = declarationProvider.getPropertyDeclarations(name)
|
||||
for (propertyDeclaration in declarations) {
|
||||
val resolutionScope = getScopeForMemberDeclarationResolution(propertyDeclaration)
|
||||
val propertyDescriptor = resolveSession.getDescriptorResolver().resolvePropertyDescriptor(
|
||||
val propertyDescriptor = c.descriptorResolver.resolvePropertyDescriptor(
|
||||
thisDescriptor,
|
||||
resolutionScope,
|
||||
propertyDeclaration,
|
||||
trace,
|
||||
// this relies on the assumption that a lazily resolved declaration is not a local one,
|
||||
// thus doesn't have a surrounding data flow
|
||||
DataFlowInfo.EMPTY)
|
||||
c.scopeProvider.getOuterDataFlowInfoForDeclaration(propertyDeclaration))
|
||||
result.add(propertyDescriptor)
|
||||
AnnotationResolver.resolveAnnotationsArguments(propertyDescriptor.getAnnotations(), trace)
|
||||
}
|
||||
|
||||
@@ -20,6 +20,7 @@ import com.google.common.base.Predicate;
|
||||
import com.google.common.collect.Collections2;
|
||||
import com.google.common.collect.Lists;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiNameIdentifierOwner;
|
||||
import kotlin.Function0;
|
||||
import kotlin.Function1;
|
||||
import kotlin.KotlinPackage;
|
||||
@@ -28,20 +29,16 @@ import org.jetbrains.annotations.Mutable;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.jetbrains.annotations.ReadOnly;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyClassContext;
|
||||
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
|
||||
import org.jetbrains.kotlin.descriptors.*;
|
||||
import org.jetbrains.kotlin.descriptors.annotations.Annotations;
|
||||
import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase;
|
||||
import org.jetbrains.kotlin.name.Name;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
import org.jetbrains.kotlin.resolve.BindingContext;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorUtils;
|
||||
import org.jetbrains.kotlin.resolve.ModifiersChecker;
|
||||
import org.jetbrains.kotlin.resolve.TypeHierarchyResolver;
|
||||
import org.jetbrains.kotlin.resolve.*;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyEntity;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil;
|
||||
import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo;
|
||||
import org.jetbrains.kotlin.resolve.lazy.data.SyntheticClassObjectInfo;
|
||||
@@ -59,8 +56,10 @@ import org.jetbrains.kotlin.types.TypeUtils;
|
||||
import java.util.*;
|
||||
|
||||
import static org.jetbrains.kotlin.diagnostics.Errors.CLASS_OBJECT_NOT_ALLOWED;
|
||||
import static org.jetbrains.kotlin.diagnostics.Errors.CYCLIC_INHERITANCE_HIERARCHY;
|
||||
import static org.jetbrains.kotlin.diagnostics.Errors.TYPE_PARAMETERS_IN_ENUM;
|
||||
import static org.jetbrains.kotlin.name.SpecialNames.getClassObjectName;
|
||||
import static org.jetbrains.kotlin.resolve.BindingContext.TYPE;
|
||||
import static org.jetbrains.kotlin.resolve.DescriptorUtils.isSyntheticClassObject;
|
||||
import static org.jetbrains.kotlin.resolve.ModifiersChecker.*;
|
||||
import static org.jetbrains.kotlin.resolve.source.SourcePackage.toSourceElement;
|
||||
@@ -73,7 +72,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
return TypeUtils.getClassDescriptor(type) != null;
|
||||
}
|
||||
};
|
||||
private final ResolveSession resolveSession;
|
||||
private final LazyClassContext c;
|
||||
|
||||
private final JetClassLikeInfo originalClassInfo;
|
||||
private final ClassMemberDeclarationProvider declarationProvider;
|
||||
@@ -99,25 +98,26 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
private final NullableLazyValue<Void> forceResolveAllContents;
|
||||
|
||||
public LazyClassDescriptor(
|
||||
@NotNull final ResolveSession resolveSession,
|
||||
@NotNull LazyClassContext c,
|
||||
@NotNull DeclarationDescriptor containingDeclaration,
|
||||
@NotNull Name name,
|
||||
@NotNull JetClassLikeInfo classLikeInfo
|
||||
) {
|
||||
super(resolveSession.getStorageManager(), containingDeclaration, name,
|
||||
super(c.getStorageManager(), containingDeclaration, name,
|
||||
toSourceElement(classLikeInfo.getCorrespondingClassOrObject())
|
||||
);
|
||||
this.resolveSession = resolveSession;
|
||||
this.c = c;
|
||||
|
||||
if (classLikeInfo.getCorrespondingClassOrObject() != null) {
|
||||
this.resolveSession.getTrace().record(BindingContext.CLASS, classLikeInfo.getCorrespondingClassOrObject(), this);
|
||||
@Nullable JetClassOrObject classOrObject = classLikeInfo.getCorrespondingClassOrObject();
|
||||
if (classOrObject != null) {
|
||||
this.c.getTrace().record(BindingContext.CLASS, classOrObject, this);
|
||||
}
|
||||
this.resolveSession.getTrace().record(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, DescriptorUtils.getFqName(this), this);
|
||||
this.c.getTrace().record(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, DescriptorUtils.getFqName(this), this);
|
||||
|
||||
this.originalClassInfo = classLikeInfo;
|
||||
this.declarationProvider = resolveSession.getDeclarationProviderFactory().getClassMemberDeclarationProvider(classLikeInfo);
|
||||
this.declarationProvider = c.getDeclarationProviderFactory().getClassMemberDeclarationProvider(classLikeInfo);
|
||||
|
||||
this.unsubstitutedMemberScope = createMemberScope(resolveSession, this.declarationProvider);
|
||||
this.unsubstitutedMemberScope = createMemberScope(c, this.declarationProvider);
|
||||
|
||||
this.typeConstructor = new LazyClassTypeConstructor();
|
||||
|
||||
@@ -131,26 +131,27 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
Modality defaultModality = kind == ClassKind.TRAIT ? Modality.ABSTRACT : Modality.FINAL;
|
||||
this.modality = resolveModalityFromModifiers(modifierList, defaultModality);
|
||||
}
|
||||
|
||||
boolean isLocal = classOrObject != null && JetPsiUtil.isLocal(classOrObject);
|
||||
this.visibility = isSyntheticClassObject(this)
|
||||
? DescriptorUtils.getSyntheticClassObjectVisibility()
|
||||
: resolveVisibilityFromModifiers(modifierList, getDefaultClassVisibility(this));
|
||||
: isLocal ? Visibilities.LOCAL : resolveVisibilityFromModifiers(modifierList, getDefaultClassVisibility(this));
|
||||
this.isInner = isInnerClass(modifierList) && !ModifiersChecker.isIllegalInner(this);
|
||||
|
||||
StorageManager storageManager = resolveSession.getStorageManager();
|
||||
StorageManager storageManager = c.getStorageManager();
|
||||
|
||||
|
||||
if (modifierList != null) {
|
||||
this.annotations = new LazyAnnotations(
|
||||
new LazyAnnotationsContext(
|
||||
resolveSession.getAnnotationResolver(),
|
||||
c.getAnnotationResolver(),
|
||||
storageManager,
|
||||
resolveSession.getTrace()
|
||||
c.getTrace()
|
||||
) {
|
||||
@NotNull
|
||||
@Override
|
||||
public JetScope getScope() {
|
||||
JetClassLikeInfo ownerInfo = declarationProvider.getOwnerInfo();
|
||||
return resolveSession.getScopeProvider().getResolutionScopeForDeclaration(ownerInfo.getScopeAnchor());
|
||||
return getOuterScope();
|
||||
}
|
||||
},
|
||||
modifierList.getAnnotationEntries()
|
||||
@@ -168,9 +169,9 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
else {
|
||||
this.danglingAnnotations = new LazyAnnotations(
|
||||
new LazyAnnotationsContext(
|
||||
resolveSession.getAnnotationResolver(),
|
||||
c.getAnnotationResolver(),
|
||||
storageManager,
|
||||
resolveSession.getTrace()
|
||||
c.getTrace()
|
||||
) {
|
||||
@NotNull
|
||||
@Override
|
||||
@@ -224,10 +225,10 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
// NOTE: Called from constructor!
|
||||
@NotNull
|
||||
protected LazyClassMemberScope createMemberScope(
|
||||
@NotNull ResolveSession resolveSession,
|
||||
@NotNull LazyClassContext c,
|
||||
@NotNull ClassMemberDeclarationProvider declarationProvider
|
||||
) {
|
||||
return new LazyClassMemberScope(resolveSession, declarationProvider, this, resolveSession.getTrace());
|
||||
return new LazyClassMemberScope(c, declarationProvider, this, c.getTrace());
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@@ -250,11 +251,12 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
}
|
||||
scope.changeLockLevel(WritableScope.LockLevel.READING);
|
||||
|
||||
PsiElement scopeAnchor = declarationProvider.getOwnerInfo().getScopeAnchor();
|
||||
return new ChainedScope(this, "ScopeForClassHeaderResolution: " + getName(), scope, getOuterScope());
|
||||
}
|
||||
|
||||
return new ChainedScope(this, "ScopeForClassHeaderResolution: " + getName(),
|
||||
scope,
|
||||
getScopeProvider().getResolutionScopeForDeclaration(scopeAnchor));
|
||||
@NotNull
|
||||
protected JetScope getOuterScope() {
|
||||
return c.getScopeProvider().getResolutionScopeForDeclaration(declarationProvider.getOwnerInfo().getScopeAnchor());
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -382,7 +384,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
private LazyClassDescriptor computeClassObjectDescriptor(@Nullable JetClassObject classObject) {
|
||||
JetClassLikeInfo classObjectInfo = getClassObjectInfo(classObject);
|
||||
if (classObjectInfo != null) {
|
||||
return new LazyClassDescriptor(resolveSession, this, getClassObjectName(getName()), classObjectInfo);
|
||||
return new LazyClassDescriptor(c, this, getClassObjectName(getName()), classObjectInfo);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
@@ -391,7 +393,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
private JetClassLikeInfo getClassObjectInfo(@Nullable JetClassObject classObject) {
|
||||
if (classObject != null) {
|
||||
if (!isClassObjectAllowed()) {
|
||||
resolveSession.getTrace().report(CLASS_OBJECT_NOT_ALLOWED.on(classObject));
|
||||
c.getTrace().report(CLASS_OBJECT_NOT_ALLOWED.on(classObject));
|
||||
}
|
||||
|
||||
return JetClassInfoUtil.createClassLikeInfo(classObject.getObjectDeclaration());
|
||||
@@ -410,7 +412,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
}
|
||||
|
||||
private boolean isClassObjectAllowed() {
|
||||
return !(getKind().isSingleton() || isInner());
|
||||
return !(getKind().isSingleton() || isInner() || DescriptorUtils.isLocal(this));
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@@ -524,7 +526,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
}
|
||||
|
||||
private class LazyClassTypeConstructor extends AbstractClassTypeConstructor implements LazyEntity {
|
||||
private final NotNullLazyValue<Supertypes> supertypes = resolveSession.getStorageManager().createLazyValueWithPostCompute(
|
||||
private final NotNullLazyValue<Supertypes> supertypes = c.getStorageManager().createLazyValueWithPostCompute(
|
||||
new Function0<Supertypes>() {
|
||||
@Override
|
||||
public Supertypes invoke() {
|
||||
@@ -542,12 +544,12 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
|
||||
JetClassOrObject classOrObject = info.getCorrespondingClassOrObject();
|
||||
if (classOrObject == null) {
|
||||
return new Supertypes(Collections.singleton(resolveSession.getModuleDescriptor().getBuiltIns().getAnyType()));
|
||||
return new Supertypes(Collections.singleton(c.getModuleDescriptor().getBuiltIns().getAnyType()));
|
||||
}
|
||||
|
||||
List<JetType> allSupertypes = resolveSession.getDescriptorResolver()
|
||||
List<JetType> allSupertypes = c.getDescriptorResolver()
|
||||
.resolveSupertypes(getScopeForClassHeaderResolution(), LazyClassDescriptor.this, classOrObject,
|
||||
resolveSession.getTrace());
|
||||
c.getTrace());
|
||||
|
||||
return new Supertypes(Lists.newArrayList(Collections2.filter(allSupertypes, VALID_SUPERTYPE)));
|
||||
}
|
||||
@@ -567,7 +569,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
}
|
||||
);
|
||||
|
||||
private final NotNullLazyValue<List<TypeParameterDescriptor>> parameters = resolveSession.getStorageManager().createLazyValue(new Function0<List<TypeParameterDescriptor>>() {
|
||||
private final NotNullLazyValue<List<TypeParameterDescriptor>> parameters = c.getStorageManager().createLazyValue(new Function0<List<TypeParameterDescriptor>>() {
|
||||
@Override
|
||||
public List<TypeParameterDescriptor> invoke() {
|
||||
JetClassLikeInfo classInfo = declarationProvider.getOwnerInfo();
|
||||
@@ -575,13 +577,13 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
if (typeParameterList == null) return Collections.emptyList();
|
||||
|
||||
if (classInfo.getClassKind() == ClassKind.ENUM_CLASS) {
|
||||
resolveSession.getTrace().report(TYPE_PARAMETERS_IN_ENUM.on(typeParameterList));
|
||||
c.getTrace().report(TYPE_PARAMETERS_IN_ENUM.on(typeParameterList));
|
||||
}
|
||||
|
||||
List<JetTypeParameter> typeParameters = typeParameterList.getParameters();
|
||||
List<TypeParameterDescriptor> parameters = new ArrayList<TypeParameterDescriptor>(typeParameters.size());
|
||||
for (int i = 0; i < typeParameters.size(); i++) {
|
||||
parameters.add(new LazyTypeParameterDescriptor(resolveSession, LazyClassDescriptor.this, typeParameters.get(i), i));
|
||||
parameters.add(new LazyTypeParameterDescriptor(c, LazyClassDescriptor.this, typeParameters.get(i), i));
|
||||
}
|
||||
|
||||
return parameters;
|
||||
@@ -589,7 +591,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
});
|
||||
|
||||
private final NullableLazyValue<Void> forceResolveAllContents =
|
||||
resolveSession.getStorageManager().createRecursionTolerantNullableLazyValue(new Function0<Void>() {
|
||||
c.getStorageManager().createRecursionTolerantNullableLazyValue(new Function0<Void>() {
|
||||
@Override
|
||||
public Void invoke() {
|
||||
doForceResolveAllContents();
|
||||
@@ -619,13 +621,43 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
ClassifierDescriptor supertypeDescriptor = supertype.getConstructor().getDeclarationDescriptor();
|
||||
if (supertypeDescriptor instanceof ClassDescriptor) {
|
||||
ClassDescriptor superclass = (ClassDescriptor) supertypeDescriptor;
|
||||
TypeHierarchyResolver.reportCyclicInheritanceHierarchyError(resolveSession.getTrace(), LazyClassDescriptor.this,
|
||||
superclass);
|
||||
reportCyclicInheritanceHierarchyError(c.getTrace(), LazyClassDescriptor.this, superclass);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void reportCyclicInheritanceHierarchyError(
|
||||
@NotNull BindingTrace trace,
|
||||
@NotNull ClassDescriptor classDescriptor,
|
||||
@NotNull ClassDescriptor superclass
|
||||
) {
|
||||
PsiElement psiElement = DescriptorToSourceUtils.classDescriptorToDeclaration(classDescriptor);
|
||||
|
||||
PsiElement elementToMark = null;
|
||||
if (psiElement instanceof JetClassOrObject) {
|
||||
JetClassOrObject classOrObject = (JetClassOrObject) psiElement;
|
||||
for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
|
||||
JetTypeReference typeReference = delegationSpecifier.getTypeReference();
|
||||
if (typeReference == null) continue;
|
||||
JetType supertype = trace.get(TYPE, typeReference);
|
||||
if (supertype != null && supertype.getConstructor() == superclass.getTypeConstructor()) {
|
||||
elementToMark = typeReference;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (elementToMark == null && psiElement instanceof PsiNameIdentifierOwner) {
|
||||
PsiNameIdentifierOwner namedElement = (PsiNameIdentifierOwner) psiElement;
|
||||
PsiElement nameIdentifier = namedElement.getNameIdentifier();
|
||||
if (nameIdentifier != null) {
|
||||
elementToMark = nameIdentifier;
|
||||
}
|
||||
}
|
||||
if (elementToMark != null) {
|
||||
trace.report(CYCLIC_INHERITANCE_HIERARCHY.on(elementToMark));
|
||||
}
|
||||
}
|
||||
|
||||
private boolean isReachable(TypeConstructor from, TypeConstructor to, Set<TypeConstructor> visited) {
|
||||
if (!visited.add(from)) return false;
|
||||
for (JetType supertype : getNeighbors(from)) {
|
||||
@@ -695,9 +727,4 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
|
||||
ForceResolveUtil.forceResolveAllContents(getParameters());
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private ScopeProvider getScopeProvider() {
|
||||
return resolveSession.getScopeProvider();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.diagnostics.Errors
|
||||
import org.jetbrains.kotlin.psi.*
|
||||
import org.jetbrains.kotlin.resolve.*
|
||||
import org.jetbrains.kotlin.resolve.dataClassUtils.*
|
||||
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
|
||||
import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider
|
||||
import org.jetbrains.kotlin.name.Name
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope
|
||||
@@ -40,12 +39,15 @@ import org.jetbrains.kotlin.resolve.DelegationResolver.generateDelegatedMembers
|
||||
import org.jetbrains.kotlin.storage.NotNullLazyValue
|
||||
import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
|
||||
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
|
||||
import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral
|
||||
|
||||
public open class LazyClassMemberScope(resolveSession: ResolveSession,
|
||||
declarationProvider: ClassMemberDeclarationProvider,
|
||||
thisClass: LazyClassDescriptor,
|
||||
trace: BindingTrace)
|
||||
: AbstractLazyMemberScope<LazyClassDescriptor, ClassMemberDeclarationProvider>(resolveSession, declarationProvider, thisClass, trace) {
|
||||
public open class LazyClassMemberScope(
|
||||
c: org.jetbrains.kotlin.resolve.lazy.LazyClassContext,
|
||||
declarationProvider: ClassMemberDeclarationProvider,
|
||||
thisClass: LazyClassDescriptor,
|
||||
trace: BindingTrace
|
||||
) : AbstractLazyMemberScope<LazyClassDescriptor, ClassMemberDeclarationProvider>(c, declarationProvider, thisClass, trace) {
|
||||
|
||||
private val descriptorsFromDeclaredElements = storageManager.createLazyValue {
|
||||
computeDescriptorsFromDeclaredElements(DescriptorKindFilter.ALL, JetScope.ALL_NAME_FILTER)
|
||||
@@ -86,7 +88,7 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession,
|
||||
}
|
||||
|
||||
private val primaryConstructor: NullableLazyValue<ConstructorDescriptor>
|
||||
= resolveSession.getStorageManager().createNullableLazyValue { resolvePrimaryConstructor() }
|
||||
= c.storageManager.createNullableLazyValue { resolvePrimaryConstructor() }
|
||||
|
||||
override fun getScopeForMemberDeclarationResolution(declaration: JetDeclaration): JetScope {
|
||||
if (declaration is JetProperty) {
|
||||
@@ -219,7 +221,7 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession,
|
||||
|
||||
val parameter = primaryConstructorParameters.get(valueParameterDescriptor.getIndex())
|
||||
if (parameter.hasValOrVarNode()) {
|
||||
val propertyDescriptor = resolveSession.getDescriptorResolver().resolvePrimaryConstructorParameterToAProperty(
|
||||
val propertyDescriptor = c.descriptorResolver.resolvePrimaryConstructorParameterToAProperty(
|
||||
thisDescriptor, valueParameterDescriptor, thisDescriptor.getScopeForClassHeaderResolution(), parameter, trace)
|
||||
result.add(propertyDescriptor)
|
||||
}
|
||||
@@ -231,7 +233,7 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession,
|
||||
?: return setOf() // Enum class objects do not have delegated members
|
||||
|
||||
val lazyTypeResolver = DelegationResolver.TypeResolver { reference ->
|
||||
resolveSession.getTypeResolver().resolveType(thisDescriptor.getScopeForClassHeaderResolution(), reference, trace, false)
|
||||
c.typeResolver.resolveType(thisDescriptor.getScopeForClassHeaderResolution(), reference, trace, false)
|
||||
}
|
||||
val lazyMemberExtractor = DelegationResolver.MemberExtractor<T> {
|
||||
type -> extractor.extract(type, name)
|
||||
@@ -271,10 +273,10 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession,
|
||||
if (GENERATE_CONSTRUCTORS_FOR.contains(thisDescriptor.getKind())) {
|
||||
val ownerInfo = declarationProvider.getOwnerInfo()
|
||||
val classOrObject = ownerInfo.getCorrespondingClassOrObject()
|
||||
if (!thisDescriptor.getKind().isSingleton()) {
|
||||
if (!thisDescriptor.getKind().isSingleton() && !classOrObject.isObjectLiteral()) {
|
||||
assert(classOrObject is JetClass) { "No JetClass for $thisDescriptor" }
|
||||
classOrObject as JetClass
|
||||
val constructor = resolveSession.getDescriptorResolver().resolvePrimaryConstructorDescriptor(
|
||||
val constructor = c.descriptorResolver.resolvePrimaryConstructorDescriptor(
|
||||
thisDescriptor.getScopeForClassHeaderResolution(), thisDescriptor, classOrObject, trace)
|
||||
assert(constructor != null) { "No constructor created for $thisDescriptor" }
|
||||
setDeferredReturnType(constructor)
|
||||
@@ -290,7 +292,7 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession,
|
||||
}
|
||||
|
||||
protected fun setDeferredReturnType(descriptor: ConstructorDescriptorImpl) {
|
||||
descriptor.setReturnType(DeferredType.create(resolveSession.getStorageManager(), trace, { thisDescriptor.getDefaultType() }))
|
||||
descriptor.setReturnType(DeferredType.create(c.storageManager, trace, { thisDescriptor.getDefaultType() }))
|
||||
}
|
||||
|
||||
// Do not add details here, they may compromise the laziness during debugging
|
||||
|
||||
@@ -24,10 +24,10 @@ import org.jetbrains.kotlin.name.Name
|
||||
import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
|
||||
|
||||
public class LazyPackageMemberScope(
|
||||
resolveSession: ResolveSession,
|
||||
private val _resolveSession: ResolveSession,
|
||||
declarationProvider: PackageMemberDeclarationProvider,
|
||||
thisPackage: PackageFragmentDescriptor)
|
||||
: AbstractLazyMemberScope<PackageFragmentDescriptor, PackageMemberDeclarationProvider>(resolveSession, declarationProvider, thisPackage, resolveSession.getTrace()) {
|
||||
: AbstractLazyMemberScope<PackageFragmentDescriptor, PackageMemberDeclarationProvider>(_resolveSession, declarationProvider, thisPackage, _resolveSession.getTrace()) {
|
||||
|
||||
override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
|
||||
return computeDescriptorsFromDeclaredElements(kindFilter, nameFilter)
|
||||
@@ -36,7 +36,7 @@ public class LazyPackageMemberScope(
|
||||
override fun getPackage(name: Name): PackageViewDescriptor? = null
|
||||
|
||||
override fun getScopeForMemberDeclarationResolution(declaration: JetDeclaration)
|
||||
= resolveSession.getScopeProvider().getFileScope(declaration.getContainingJetFile())
|
||||
= _resolveSession.getScopeProvider().getFileScope(declaration.getContainingJetFile())
|
||||
|
||||
override fun getNonDeclaredFunctions(name: Name, result: MutableSet<FunctionDescriptor>) {
|
||||
// No extra functions
|
||||
|
||||
@@ -17,6 +17,7 @@
|
||||
package org.jetbrains.kotlin.resolve.lazy.descriptors;
|
||||
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyClassContext;
|
||||
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.Visibilities;
|
||||
import org.jetbrains.kotlin.descriptors.Visibility;
|
||||
@@ -39,13 +40,15 @@ public class LazyScriptClassDescriptor extends LazyClassDescriptor {
|
||||
@NotNull
|
||||
@Override
|
||||
protected LazyScriptClassMemberScope createMemberScope(
|
||||
@NotNull ResolveSession resolveSession, @NotNull ClassMemberDeclarationProvider declarationProvider
|
||||
@NotNull LazyClassContext c,
|
||||
@NotNull ClassMemberDeclarationProvider declarationProvider
|
||||
) {
|
||||
return new LazyScriptClassMemberScope(
|
||||
resolveSession,
|
||||
// Must be a ResolveSession for scripts
|
||||
(ResolveSession) c,
|
||||
declarationProvider,
|
||||
this,
|
||||
TemporaryBindingTrace.create(resolveSession.getTrace(), "A trace for script class, needed to avoid rewrites on members")
|
||||
TemporaryBindingTrace.create(c.getTrace(), "A trace for script class, needed to avoid rewrites on members")
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -66,14 +66,14 @@ public class LazyScriptClassMemberScope protected(
|
||||
|
||||
for (valueParameterDescriptor in primaryConstructor.getValueParameters()) {
|
||||
if (name == valueParameterDescriptor.getName()) {
|
||||
result.add(ScriptDescriptorImpl.createPropertyFromScriptParameter(resolveSession.getScriptDescriptor(scriptInfo.script), valueParameterDescriptor))
|
||||
result.add(ScriptDescriptorImpl.createPropertyFromScriptParameter((c as ResolveSession).getScriptDescriptor(scriptInfo.script), valueParameterDescriptor))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun resolvePrimaryConstructor(): ConstructorDescriptor? {
|
||||
val scriptInfo = declarationProvider.getOwnerInfo() as JetScriptInfo
|
||||
val scriptDescriptor = resolveSession.getScriptDescriptor(scriptInfo.script)
|
||||
val scriptDescriptor = (c as ResolveSession).getScriptDescriptor(scriptInfo.script)
|
||||
val constructor = ScriptDescriptorImpl.createConstructor(scriptDescriptor, scriptDescriptor.getScriptCodeDescriptor().getValueParameters())
|
||||
setDeferredReturnType(constructor)
|
||||
return constructor
|
||||
|
||||
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve.lazy.descriptors;
|
||||
|
||||
import com.google.common.collect.Sets;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyClassContext;
|
||||
import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor;
|
||||
import org.jetbrains.kotlin.lexer.JetTokens;
|
||||
import org.jetbrains.kotlin.psi.*;
|
||||
@@ -25,7 +26,6 @@ import org.jetbrains.kotlin.resolve.BindingContext;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyEntity;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
|
||||
import org.jetbrains.kotlin.types.JetType;
|
||||
|
||||
import java.util.Set;
|
||||
@@ -33,17 +33,17 @@ import java.util.Set;
|
||||
import static org.jetbrains.kotlin.resolve.source.SourcePackage.toSourceElement;
|
||||
|
||||
public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescriptor implements LazyEntity {
|
||||
private final ResolveSession resolveSession;
|
||||
private final LazyClassContext c;
|
||||
|
||||
private final JetTypeParameter jetTypeParameter;
|
||||
|
||||
public LazyTypeParameterDescriptor(
|
||||
@NotNull ResolveSession resolveSession,
|
||||
@NotNull LazyClassContext c,
|
||||
@NotNull LazyClassDescriptor containingDeclaration,
|
||||
@NotNull JetTypeParameter jetTypeParameter,
|
||||
int index) {
|
||||
super(
|
||||
resolveSession.getStorageManager(),
|
||||
c.getStorageManager(),
|
||||
containingDeclaration,
|
||||
jetTypeParameter.getNameAsSafeName(),
|
||||
jetTypeParameter.getVariance(),
|
||||
@@ -51,10 +51,10 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
|
||||
index,
|
||||
toSourceElement(jetTypeParameter)
|
||||
);
|
||||
this.resolveSession = resolveSession;
|
||||
this.c = c;
|
||||
this.jetTypeParameter = jetTypeParameter;
|
||||
|
||||
this.resolveSession.getTrace().record(BindingContext.TYPE_PARAMETER, jetTypeParameter, this);
|
||||
this.c.getTrace().record(BindingContext.TYPE_PARAMETER, jetTypeParameter, this);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@@ -72,7 +72,7 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
|
||||
resolveUpperBoundsFromWhereClause(upperBounds);
|
||||
|
||||
if (upperBounds.isEmpty()) {
|
||||
upperBounds.add(resolveSession.getModuleDescriptor().getBuiltIns().getDefaultBound());
|
||||
upperBounds.add(c.getModuleDescriptor().getBuiltIns().getDefaultBound());
|
||||
}
|
||||
|
||||
return upperBounds;
|
||||
@@ -83,12 +83,12 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
|
||||
if (classOrObject instanceof JetClass) {
|
||||
JetClass jetClass = (JetClass) classOrObject;
|
||||
for (JetTypeConstraint jetTypeConstraint : jetClass.getTypeConstraints()) {
|
||||
DescriptorResolver.reportUnsupportedClassObjectConstraint(resolveSession.getTrace(), jetTypeConstraint);
|
||||
DescriptorResolver.reportUnsupportedClassObjectConstraint(c.getTrace(), jetTypeConstraint);
|
||||
|
||||
JetSimpleNameExpression constrainedParameterName = jetTypeConstraint.getSubjectTypeParameterName();
|
||||
if (constrainedParameterName != null) {
|
||||
if (getName().equals(constrainedParameterName.getReferencedNameAsName())) {
|
||||
resolveSession.getTrace().record(BindingContext.REFERENCE_TARGET, constrainedParameterName, this);
|
||||
c.getTrace().record(BindingContext.REFERENCE_TARGET, constrainedParameterName, this);
|
||||
|
||||
JetTypeReference boundTypeReference = jetTypeConstraint.getBoundTypeReference();
|
||||
if (boundTypeReference != null) {
|
||||
@@ -105,9 +105,9 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
|
||||
}
|
||||
|
||||
private JetType resolveBoundType(@NotNull JetTypeReference boundTypeReference) {
|
||||
return resolveSession.getTypeResolver()
|
||||
return c.getTypeResolver()
|
||||
.resolveType(getContainingDeclaration().getScopeForClassHeaderResolution(), boundTypeReference,
|
||||
resolveSession.getTrace(), false);
|
||||
c.getTrace(), false);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
|
||||
@@ -1,105 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.types.expressions;
|
||||
|
||||
import com.google.common.base.Predicates;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.jetbrains.kotlin.context.GlobalContext;
|
||||
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor;
|
||||
import org.jetbrains.kotlin.descriptors.impl.PackageLikeBuilder;
|
||||
import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerBasic;
|
||||
import org.jetbrains.kotlin.psi.JetClassOrObject;
|
||||
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorUtils;
|
||||
import org.jetbrains.kotlin.resolve.TopDownAnalysisContext;
|
||||
import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters;
|
||||
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
|
||||
import org.jetbrains.kotlin.types.DynamicTypesSettings;
|
||||
|
||||
import java.util.Collections;
|
||||
|
||||
public class LocalClassifierAnalyzer {
|
||||
public void processClassOrObject(
|
||||
@NotNull GlobalContext globalContext,
|
||||
@Nullable final WritableScope scope,
|
||||
@NotNull ExpressionTypingContext context,
|
||||
@NotNull final DeclarationDescriptor containingDeclaration,
|
||||
@NotNull JetClassOrObject object,
|
||||
@NotNull AdditionalCheckerProvider additionalCheckerProvider,
|
||||
@NotNull DynamicTypesSettings dynamicTypesSettings
|
||||
) {
|
||||
TopDownAnalysisParameters topDownAnalysisParameters =
|
||||
TopDownAnalysisParameters.createForLocalDeclarations(
|
||||
globalContext.getStorageManager(),
|
||||
globalContext.getExceptionTracker(),
|
||||
Predicates.equalTo(object.getContainingFile())
|
||||
);
|
||||
|
||||
InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
|
||||
object.getProject(),
|
||||
topDownAnalysisParameters,
|
||||
context.trace,
|
||||
DescriptorUtils.getContainingModule(containingDeclaration),
|
||||
additionalCheckerProvider,
|
||||
dynamicTypesSettings
|
||||
);
|
||||
|
||||
TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters);
|
||||
c.setOuterDataFlowInfo(context.dataFlowInfo);
|
||||
|
||||
injector.getTopDownAnalyzer().doProcess(
|
||||
c,
|
||||
context.scope,
|
||||
new PackageLikeBuilder() {
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public DeclarationDescriptor getOwnerForChildren() {
|
||||
return containingDeclaration;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
|
||||
if (scope != null) {
|
||||
scope.addClassifierDescriptor(classDescriptor);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
|
||||
return null;
|
||||
}
|
||||
},
|
||||
Collections.<PsiElement>singletonList(object)
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,194 @@
|
||||
/*
|
||||
* Copyright 2010-2015 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jetbrains.kotlin.types.expressions
|
||||
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver
|
||||
import org.jetbrains.kotlin.resolve.AnnotationResolver
|
||||
import org.jetbrains.kotlin.context.GlobalContext
|
||||
import org.jetbrains.kotlin.resolve.scopes.WritableScope
|
||||
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
|
||||
import org.jetbrains.kotlin.psi.JetClassOrObject
|
||||
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
|
||||
import org.jetbrains.kotlin.types.DynamicTypesSettings
|
||||
import com.google.common.base.Predicates
|
||||
import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters
|
||||
import org.jetbrains.kotlin.resolve.DescriptorUtils
|
||||
import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer
|
||||
import org.jetbrains.kotlin.storage.StorageManager
|
||||
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
|
||||
import org.jetbrains.kotlin.descriptors.ClassDescriptor
|
||||
import com.intellij.psi.PsiElement
|
||||
import com.intellij.psi.util.PsiTreeUtil
|
||||
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider
|
||||
import org.jetbrains.kotlin.psi.debugText.getDebugText
|
||||
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
|
||||
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
|
||||
import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo
|
||||
import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider
|
||||
import org.jetbrains.kotlin.resolve.lazy.declarations.PsiBasedClassMemberDeclarationProvider
|
||||
import org.jetbrains.kotlin.name.FqName
|
||||
import org.jetbrains.kotlin.resolve.lazy.declarations.PackageMemberDeclarationProvider
|
||||
import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral
|
||||
import org.jetbrains.kotlin.name.SpecialNames
|
||||
import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil
|
||||
import org.jetbrains.kotlin.resolve.scopes.JetScope
|
||||
import org.jetbrains.kotlin.resolve.BindingTrace
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver
|
||||
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl
|
||||
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
|
||||
|
||||
public class LocalClassifierAnalyzer(
|
||||
val descriptorResolver: DescriptorResolver,
|
||||
val typeResolver: TypeResolver,
|
||||
val annotationResolver: AnnotationResolver
|
||||
) {
|
||||
fun processClassOrObject(
|
||||
globalContext: GlobalContext,
|
||||
scope: WritableScope?,
|
||||
context: ExpressionTypingContext,
|
||||
containingDeclaration: DeclarationDescriptor,
|
||||
classOrObject: JetClassOrObject,
|
||||
additionalCheckerProvider: AdditionalCheckerProvider,
|
||||
dynamicTypesSettings: DynamicTypesSettings
|
||||
) {
|
||||
val topDownAnalysisParameters = TopDownAnalysisParameters.create(
|
||||
globalContext.storageManager,
|
||||
globalContext.exceptionTracker,
|
||||
Predicates.equalTo(classOrObject.getContainingFile()), false, true)
|
||||
|
||||
val moduleDescriptor = DescriptorUtils.getContainingModule(containingDeclaration)
|
||||
val injector = InjectorForLazyLocalClassifierAnalyzer(
|
||||
classOrObject.getProject(),
|
||||
globalContext,
|
||||
context.trace,
|
||||
moduleDescriptor,
|
||||
additionalCheckerProvider,
|
||||
dynamicTypesSettings,
|
||||
LocalClassDescriptorManager(
|
||||
scope,
|
||||
classOrObject,
|
||||
containingDeclaration,
|
||||
globalContext.storageManager,
|
||||
context,
|
||||
moduleDescriptor,
|
||||
descriptorResolver,
|
||||
typeResolver,
|
||||
annotationResolver
|
||||
)
|
||||
)
|
||||
|
||||
injector.getLazyTopDownAnalyzer().analyzeDeclarations(
|
||||
topDownAnalysisParameters,
|
||||
listOf(classOrObject),
|
||||
context.dataFlowInfo
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
class LocalClassDescriptorManager(
|
||||
val writableScope: WritableScope?,
|
||||
val myClass: JetClassOrObject,
|
||||
val containingDeclaration: DeclarationDescriptor,
|
||||
val storageManager: StorageManager,
|
||||
val expressionTypingContext: ExpressionTypingContext,
|
||||
val moduleDescriptor: ModuleDescriptor,
|
||||
val descriptorResolver: DescriptorResolver,
|
||||
val typeResolver: TypeResolver,
|
||||
val annotationResolver: AnnotationResolver
|
||||
) {
|
||||
// We do not need to synchronize here, because this code is used strictly from one thread
|
||||
private var classDescriptor: ClassDescriptor? = null
|
||||
|
||||
fun isMyClass(element: PsiElement): Boolean = element == myClass
|
||||
fun insideMyClass(element: PsiElement): Boolean = PsiTreeUtil.isAncestor(myClass, element, false)
|
||||
|
||||
fun createClassDescriptor(classOrObject: JetClassOrObject, declarationScopeProvider: DeclarationScopeProvider): ClassDescriptor {
|
||||
assert(isMyClass(classOrObject)) {"Called on a wrong class: ${classOrObject.getDebugText()}"}
|
||||
if (classDescriptor == null) {
|
||||
classDescriptor = LazyClassDescriptor(
|
||||
object : org.jetbrains.kotlin.resolve.lazy.LazyClassContext {
|
||||
override val scopeProvider = declarationScopeProvider
|
||||
override val storageManager = this@LocalClassDescriptorManager.storageManager
|
||||
override val trace = expressionTypingContext.trace
|
||||
override val moduleDescriptor = this@LocalClassDescriptorManager.moduleDescriptor
|
||||
override val descriptorResolver = this@LocalClassDescriptorManager.descriptorResolver
|
||||
override val typeResolver = this@LocalClassDescriptorManager.typeResolver
|
||||
override val declarationProviderFactory = object : DeclarationProviderFactory {
|
||||
override fun getClassMemberDeclarationProvider(classLikeInfo: JetClassLikeInfo): ClassMemberDeclarationProvider {
|
||||
return PsiBasedClassMemberDeclarationProvider(storageManager, classLikeInfo)
|
||||
}
|
||||
|
||||
override fun getPackageMemberDeclarationProvider(packageFqName: FqName): PackageMemberDeclarationProvider? {
|
||||
throw UnsupportedOperationException("Should not be called for top-level declarations")
|
||||
}
|
||||
|
||||
}
|
||||
override val annotationResolver = this@LocalClassDescriptorManager.annotationResolver
|
||||
}
|
||||
,
|
||||
containingDeclaration,
|
||||
if (classOrObject.isObjectLiteral()) SpecialNames.NO_NAME_PROVIDED else classOrObject.getNameAsSafeName(),
|
||||
JetClassInfoUtil.createClassLikeInfo(classOrObject)
|
||||
)
|
||||
writableScope?.addClassifierDescriptor(classDescriptor!!)
|
||||
}
|
||||
|
||||
return classDescriptor!!
|
||||
}
|
||||
|
||||
fun getResolutionScopeForClass(classOrObject: JetClassOrObject): JetScope {
|
||||
assert (isMyClass(classOrObject)) {"Called on a wrong class: ${classOrObject.getDebugText()}"}
|
||||
return expressionTypingContext.scope
|
||||
}
|
||||
}
|
||||
|
||||
class LocalLazyDeclarationResolver(
|
||||
globalContext: GlobalContext,
|
||||
trace: BindingTrace,
|
||||
val localClassDescriptorManager: LocalClassDescriptorManager
|
||||
) : LazyDeclarationResolver(globalContext, trace) {
|
||||
|
||||
override fun getClassDescriptor(classOrObject: JetClassOrObject): ClassDescriptor {
|
||||
if (localClassDescriptorManager.isMyClass(classOrObject)) {
|
||||
return localClassDescriptorManager.createClassDescriptor(classOrObject, scopeProvider)
|
||||
}
|
||||
return super.getClassDescriptor(classOrObject)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class DeclarationScopeProviderForLocalClassifierAnalyzer(
|
||||
lazyDeclarationResolver: LazyDeclarationResolver,
|
||||
val localClassDescriptorManager: LocalClassDescriptorManager
|
||||
) : DeclarationScopeProviderImpl(lazyDeclarationResolver) {
|
||||
override fun getResolutionScopeForDeclaration(elementOfDeclaration: PsiElement): JetScope {
|
||||
if (localClassDescriptorManager.isMyClass(elementOfDeclaration)) {
|
||||
return localClassDescriptorManager.getResolutionScopeForClass(elementOfDeclaration as JetClassOrObject)
|
||||
}
|
||||
return super.getResolutionScopeForDeclaration(elementOfDeclaration)
|
||||
}
|
||||
|
||||
override fun getOuterDataFlowInfoForDeclaration(elementOfDeclaration: PsiElement): DataFlowInfo {
|
||||
// nested (non-inner) classes and class objects are forbidden in local classes, so it's enough to be simply inside the class
|
||||
if (localClassDescriptorManager.insideMyClass(elementOfDeclaration)) {
|
||||
return localClassDescriptorManager.expressionTypingContext.dataFlowInfo
|
||||
}
|
||||
return super.getOuterDataFlowInfoForDeclaration(elementOfDeclaration)
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
ERROR: compiler/testData/cli/jvm/wrongAbiVersionLib/bin/ClassWithWrongAbiVersion.class: (0, 0) Class 'ClassWithWrongAbiVersion' was compiled with an incompatible version of Kotlin. Its ABI version is -1, expected ABI version is $ABI_VERSION$
|
||||
ERROR: compiler/testData/cli/jvm/wrongAbiVersionLib/bin/wrong/WrongPackage.class: (0, 0) Class 'wrong/WrongPackage' was compiled with an incompatible version of Kotlin. Its ABI version is -1, expected ABI version is $ABI_VERSION$
|
||||
ERROR: compiler/testData/cli/jvm/wrongAbiVersionLib/bin/ClassWithWrongAbiVersion.class: (0, 0) Class 'ClassWithWrongAbiVersion' was compiled with an incompatible version of Kotlin. Its ABI version is -1, expected ABI version is $ABI_VERSION$
|
||||
WARNING: compiler/testData/cli/jvm/wrongAbiVersion.kt: (3, 9) Parameter 'x' is never used
|
||||
ERROR: compiler/testData/cli/jvm/wrongAbiVersion.kt: (4, 3) Unresolved reference: bar
|
||||
COMPILATION_ERROR
|
||||
@@ -1,29 +1,30 @@
|
||||
// !DIAGNOSTICS: -UNUSED_VARIABLE
|
||||
// KT-4351 Cannot resolve reference to self in init of class local to function
|
||||
|
||||
fun f() {
|
||||
class MyClass() {
|
||||
{
|
||||
val <!UNUSED_VARIABLE!>x<!>: MyClass = MyClass()
|
||||
val x: MyClass = MyClass()
|
||||
}
|
||||
|
||||
fun member() {
|
||||
val <!UNUSED_VARIABLE!>x<!>: MyClass = MyClass()
|
||||
val x: MyClass = MyClass()
|
||||
}
|
||||
}
|
||||
|
||||
<!LOCAL_OBJECT_NOT_ALLOWED!>object MyObject<!> {
|
||||
{
|
||||
val <!UNUSED_VARIABLE!>obj<!>: MyObject = MyObject
|
||||
val obj: MyObject = MyObject
|
||||
}
|
||||
}
|
||||
|
||||
val <!UNUSED_VARIABLE!>x<!>: MyClass = MyClass()
|
||||
val x: MyClass = MyClass()
|
||||
}
|
||||
|
||||
val closure = {
|
||||
class MyClass {
|
||||
{
|
||||
val <!UNUSED_VARIABLE!>x<!>: MyClass = MyClass()
|
||||
val x: MyClass = MyClass()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,4 +4,4 @@ class Foo {
|
||||
|
||||
// TESTED_OBJECT_KIND: class
|
||||
// TESTED_OBJECTS: Foo$x$1
|
||||
// FLAGS: ACC_PUBLIC, ACC_FINAL, ACC_SUPER
|
||||
// FLAGS: ACC_FINAL, ACC_SUPER
|
||||
|
||||
@@ -54,15 +54,15 @@ public class InnerClassInfoGenTest extends CodegenTestCase {
|
||||
}
|
||||
|
||||
public void testLocalClass() {
|
||||
InnerClassAttribute innerB = new InnerClassAttribute("A$foo$B", null, "B", ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
|
||||
InnerClassAttribute innerB = new InnerClassAttribute("A$foo$B", null, "B", ACC_STATIC | ACC_FINAL);
|
||||
|
||||
extractAndCompareInnerClasses("A", innerB);
|
||||
extractAndCompareInnerClasses("A$foo$B", innerB);
|
||||
}
|
||||
|
||||
public void testAnonymousClass() {
|
||||
InnerClassAttribute innerB = new InnerClassAttribute("A$B$1", null, null, ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
|
||||
InnerClassAttribute innerC = new InnerClassAttribute("A$foo$C$1", null, null, ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
|
||||
InnerClassAttribute innerB = new InnerClassAttribute("A$B$1", null, null, ACC_STATIC | ACC_FINAL);
|
||||
InnerClassAttribute innerC = new InnerClassAttribute("A$foo$C$1", null, null, ACC_STATIC | ACC_FINAL);
|
||||
|
||||
extractAndCompareInnerClasses("A", innerB, innerC);
|
||||
extractAndCompareInnerClasses("A$B$1", innerB);
|
||||
@@ -70,7 +70,7 @@ public class InnerClassInfoGenTest extends CodegenTestCase {
|
||||
}
|
||||
|
||||
public void testAnonymousObjectInline() {
|
||||
InnerClassAttribute objectInInlineFun = new InnerClassAttribute("A$inlineFun$s$1", null, null, ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
|
||||
InnerClassAttribute objectInInlineFun = new InnerClassAttribute("A$inlineFun$s$1", null, null, ACC_STATIC | ACC_FINAL);
|
||||
extractAndCompareInnerClasses("A", objectInInlineFun);
|
||||
}
|
||||
|
||||
|
||||
@@ -111,7 +111,7 @@ public class InjectorForTests {
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices());
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(getDescriptorResolver(), getTypeResolver(), annotationResolver);
|
||||
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
|
||||
|
||||
@@ -67,7 +67,7 @@ public class Dependencies {
|
||||
DiType typeToInitialize = InjectorGeneratorUtil.getEffectiveFieldType(field);
|
||||
|
||||
// Sort setters in order to get deterministic behavior
|
||||
List<Method> declaredMethods = Lists.newArrayList(typeToInitialize.getClazz().getDeclaredMethods());
|
||||
List<Method> declaredMethods = Lists.newArrayList(typeToInitialize.getClazz().getMethods());
|
||||
Collections.sort(declaredMethods, new Comparator<Method>() {
|
||||
@Override
|
||||
public int compare(@NotNull Method o1, @NotNull Method o2) {
|
||||
|
||||
@@ -51,6 +51,12 @@ import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
|
||||
import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
|
||||
import org.jetbrains.kotlin.types.DynamicTypesAllowed
|
||||
import org.jetbrains.kotlin.types.DynamicTypesSettings
|
||||
import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider
|
||||
import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorManager
|
||||
import org.jetbrains.kotlin.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer
|
||||
import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver
|
||||
|
||||
// NOTE: After making changes, you need to re-generate the injectors.
|
||||
// To do that, you can run main in this file.
|
||||
@@ -70,8 +76,8 @@ private val DI_DEFAULT_PACKAGE = "org.jetbrains.kotlin.di"
|
||||
|
||||
public fun createInjectorGenerators(): List<DependencyInjectorGenerator> =
|
||||
listOf(
|
||||
generatorForTopDownAnalyzerBasic(),
|
||||
generatorForLazyTopDownAnalyzerBasic(),
|
||||
generatorForLazyLocalClassifierAnalyzer(),
|
||||
generatorForTopDownAnalyzerForJvm(),
|
||||
generatorForJavaDescriptorResolver(),
|
||||
generatorForLazyResolveWithJava(),
|
||||
@@ -84,35 +90,39 @@ public fun createInjectorGenerators(): List<DependencyInjectorGenerator> =
|
||||
generatorForReplWithJava()
|
||||
)
|
||||
|
||||
private fun generatorForTopDownAnalyzerBasic() =
|
||||
generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForTopDownAnalyzerBasic") {
|
||||
parameter<Project>()
|
||||
parameter<GlobalContext>(useAsContext = true)
|
||||
parameter<BindingTrace>()
|
||||
publicParameter<ModuleDescriptor>(useAsContext = true)
|
||||
|
||||
publicField<TopDownAnalyzer>()
|
||||
|
||||
field<MutablePackageFragmentProvider>()
|
||||
|
||||
parameter<AdditionalCheckerProvider>()
|
||||
parameter<DynamicTypesSettings>()
|
||||
}
|
||||
|
||||
private fun generatorForLazyTopDownAnalyzerBasic() =
|
||||
generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyTopDownAnalyzerBasic") {
|
||||
commonForResolveSessionBased()
|
||||
|
||||
publicField<LazyTopDownAnalyzer>()
|
||||
publicField<LazyTopDownAnalyzerForTopLevel>()
|
||||
|
||||
field<AdditionalCheckerProvider.DefaultProvider>()
|
||||
}
|
||||
|
||||
private fun generatorForLazyLocalClassifierAnalyzer() =
|
||||
generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyLocalClassifierAnalyzer") {
|
||||
parameter<Project>()
|
||||
parameter<GlobalContext>(useAsContext = true)
|
||||
parameter<BindingTrace>()
|
||||
parameter<ModuleDescriptor>(name = "module", useAsContext = true)
|
||||
parameter<AdditionalCheckerProvider>()
|
||||
parameter<DynamicTypesSettings>()
|
||||
parameter<LocalClassDescriptorManager>()
|
||||
|
||||
publicField<LazyTopDownAnalyzer>()
|
||||
|
||||
field<NoTopLevelDescriptorProvider>()
|
||||
field<NoFileScopeProvider>()
|
||||
field<DeclarationScopeProviderForLocalClassifierAnalyzer>()
|
||||
field<LocalLazyDeclarationResolver>()
|
||||
}
|
||||
|
||||
private fun generatorForLazyBodyResolve() =
|
||||
generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyBodyResolve") {
|
||||
parameter<Project>()
|
||||
parameter<GlobalContext>(useAsContext = true)
|
||||
parameter<KotlinCodeAnalyzer>(name = "analyzer")
|
||||
parameter<KotlinCodeAnalyzer>(name = "analyzer", useAsContext = true)
|
||||
parameter<BindingTrace>()
|
||||
parameter<AdditionalCheckerProvider>()
|
||||
parameter<DynamicTypesSettings>()
|
||||
@@ -127,6 +137,7 @@ private fun generatorForTopDownAnalyzerForJs() =
|
||||
commonForResolveSessionBased()
|
||||
|
||||
publicField<LazyTopDownAnalyzer>()
|
||||
publicField<LazyTopDownAnalyzerForTopLevel>()
|
||||
|
||||
field<MutablePackageFragmentProvider>()
|
||||
field<KotlinJsCheckerProvider>()
|
||||
@@ -260,6 +271,7 @@ private fun generatorForLazyResolve() =
|
||||
|
||||
publicField<ResolveSession>()
|
||||
|
||||
field<ScopeProvider>()
|
||||
field<LazyResolveToken>()
|
||||
}
|
||||
|
||||
@@ -271,6 +283,7 @@ private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
|
||||
parameter<DeclarationProviderFactory>()
|
||||
|
||||
publicField<ResolveSession>()
|
||||
field<ScopeProvider>()
|
||||
}
|
||||
|
||||
private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() {
|
||||
@@ -279,6 +292,7 @@ private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() {
|
||||
parameter<GlobalSearchScope>(name = "moduleContentScope")
|
||||
|
||||
publicField<LazyTopDownAnalyzer>()
|
||||
publicField<LazyTopDownAnalyzerForTopLevel>()
|
||||
publicField<JavaDescriptorResolver>()
|
||||
publicField<DeserializationComponentsForJava>()
|
||||
|
||||
|
||||
@@ -263,7 +263,8 @@ private object KotlinResolveDataProvider {
|
||||
/* analyzingBootstrapLibrary = */ false,
|
||||
/* declaredLocally = */ false
|
||||
),
|
||||
listOf(analyzableElement)
|
||||
listOf(analyzableElement),
|
||||
DataFlowInfo.EMPTY
|
||||
)
|
||||
return AnalysisResult.success(
|
||||
trace.getBindingContext(),
|
||||
|
||||
@@ -110,8 +110,8 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
|
||||
FileBasedDeclarationProviderFactory declarationFactory =
|
||||
new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), jetBuiltInsFiles);
|
||||
|
||||
LazyTopDownAnalyzer analyzer = new InjectorForLazyTopDownAnalyzerBasic(
|
||||
myProject, topDownAnalysisParameters, trace, module, declarationFactory).getLazyTopDownAnalyzer();
|
||||
LazyTopDownAnalyzerForTopLevel analyzer = new InjectorForLazyTopDownAnalyzerBasic(
|
||||
myProject, topDownAnalysisParameters, trace, module, declarationFactory).getLazyTopDownAnalyzerForTopLevel();
|
||||
|
||||
analyzer.analyzeFiles(topDownAnalysisParameters, jetBuiltInsFiles, Collections.<PackageFragmentProvider>emptyList());
|
||||
|
||||
|
||||
@@ -25,8 +25,9 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
|
||||
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.LazyTopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.MutablePackageFragmentProvider;
|
||||
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
|
||||
import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider;
|
||||
import org.jetbrains.kotlin.types.DynamicTypesAllowed;
|
||||
import org.jetbrains.kotlin.resolve.AnnotationResolver;
|
||||
@@ -38,34 +39,31 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
|
||||
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
|
||||
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.DescriptorResolver;
|
||||
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver;
|
||||
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
|
||||
import org.jetbrains.kotlin.context.LazinessToken;
|
||||
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
|
||||
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
|
||||
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
|
||||
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
|
||||
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
|
||||
import org.jetbrains.kotlin.psi.JetImportsFactory;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
|
||||
import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
|
||||
import org.jetbrains.kotlin.resolve.BodyResolver;
|
||||
import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.DeclarationsChecker;
|
||||
import org.jetbrains.kotlin.resolve.ModifiersChecker;
|
||||
import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
|
||||
import org.jetbrains.kotlin.resolve.DeclarationResolver;
|
||||
import org.jetbrains.kotlin.resolve.ImportsResolver;
|
||||
import org.jetbrains.kotlin.resolve.OverloadResolver;
|
||||
import org.jetbrains.kotlin.resolve.OverrideResolver;
|
||||
import org.jetbrains.kotlin.resolve.TopDownAnalyzer;
|
||||
import org.jetbrains.kotlin.resolve.TypeHierarchyResolver;
|
||||
import org.jetbrains.kotlin.resolve.ScriptHeaderResolver;
|
||||
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import javax.annotation.PreDestroy;
|
||||
@@ -83,8 +81,9 @@ public class InjectorForTopDownAnalyzerForJs {
|
||||
private final PlatformToKotlinClassMap platformToKotlinClassMap;
|
||||
private final DeclarationProviderFactory declarationProviderFactory;
|
||||
private final ResolveSession resolveSession;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
|
||||
private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
|
||||
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
|
||||
private final KotlinJsCheckerProvider kotlinJsCheckerProvider;
|
||||
private final DynamicTypesAllowed dynamicTypesAllowed;
|
||||
private final AnnotationResolver annotationResolver;
|
||||
@@ -96,34 +95,31 @@ public class InjectorForTopDownAnalyzerForJs {
|
||||
private final ExpressionTypingUtils expressionTypingUtils;
|
||||
private final ForLoopConventionsChecker forLoopConventionsChecker;
|
||||
private final LocalClassifierAnalyzer localClassifierAnalyzer;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final DescriptorResolver descriptorResolver;
|
||||
private final DelegatedPropertyResolver delegatedPropertyResolver;
|
||||
private final TypeResolver typeResolver;
|
||||
private final QualifiedExpressionResolver qualifiedExpressionResolver;
|
||||
private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
|
||||
private final LazinessToken lazinessToken;
|
||||
private final ReflectionTypes reflectionTypes;
|
||||
private final CallExpressionResolver callExpressionResolver;
|
||||
private final PartialBodyResolveProvider partialBodyResolveProvider;
|
||||
private final CallCompleter callCompleter;
|
||||
private final CandidateResolver candidateResolver;
|
||||
private final TaskPrioritizer taskPrioritizer;
|
||||
private final JetImportsFactory jetImportsFactory;
|
||||
private final ScopeProvider scopeProvider;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private final LazyDeclarationResolver lazyDeclarationResolver;
|
||||
private final DeclarationScopeProviderImpl declarationScopeProvider;
|
||||
private final ScriptBodyResolver scriptBodyResolver;
|
||||
private final AdditionalFileScopeProvider additionalFileScopeProvider;
|
||||
private final BodyResolver bodyResolver;
|
||||
private final ControlFlowAnalyzer controlFlowAnalyzer;
|
||||
private final DeclarationsChecker declarationsChecker;
|
||||
private final ModifiersChecker modifiersChecker;
|
||||
private final FunctionAnalyzerExtension functionAnalyzerExtension;
|
||||
private final DeclarationResolver declarationResolver;
|
||||
private final ImportsResolver importsResolver;
|
||||
private final OverloadResolver overloadResolver;
|
||||
private final OverrideResolver overrideResolver;
|
||||
private final TopDownAnalyzer topDownAnalyzer;
|
||||
private final TypeHierarchyResolver typeHierarchyResolver;
|
||||
private final ScriptHeaderResolver scriptHeaderResolver;
|
||||
private final VarianceChecker varianceChecker;
|
||||
|
||||
public InjectorForTopDownAnalyzerForJs(
|
||||
@@ -142,8 +138,9 @@ public class InjectorForTopDownAnalyzerForJs {
|
||||
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
|
||||
this.declarationProviderFactory = declarationProviderFactory;
|
||||
this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace);
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
|
||||
this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module);
|
||||
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
|
||||
this.kotlinJsCheckerProvider = KotlinJsCheckerProvider.INSTANCE$;
|
||||
this.dynamicTypesAllowed = new DynamicTypesAllowed();
|
||||
this.annotationResolver = new AnnotationResolver();
|
||||
@@ -154,55 +151,61 @@ public class InjectorForTopDownAnalyzerForJs {
|
||||
this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
|
||||
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
|
||||
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.descriptorResolver = new DescriptorResolver();
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
|
||||
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
|
||||
this.lazinessToken = new LazinessToken();
|
||||
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesAllowed);
|
||||
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
|
||||
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
|
||||
this.reflectionTypes = new ReflectionTypes(module);
|
||||
this.callExpressionResolver = new CallExpressionResolver();
|
||||
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
|
||||
this.candidateResolver = new CandidateResolver();
|
||||
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
|
||||
this.taskPrioritizer = new TaskPrioritizer(storageManager);
|
||||
this.jetImportsFactory = new JetImportsFactory();
|
||||
this.scopeProvider = new ScopeProvider(getResolveSession());
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
|
||||
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
|
||||
this.scriptBodyResolver = new ScriptBodyResolver();
|
||||
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
|
||||
this.bodyResolver = new BodyResolver();
|
||||
this.controlFlowAnalyzer = new ControlFlowAnalyzer();
|
||||
this.declarationsChecker = new DeclarationsChecker();
|
||||
this.modifiersChecker = new ModifiersChecker(bindingTrace, kotlinJsCheckerProvider);
|
||||
this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
|
||||
this.declarationResolver = new DeclarationResolver();
|
||||
this.importsResolver = new ImportsResolver();
|
||||
this.overloadResolver = new OverloadResolver();
|
||||
this.overrideResolver = new OverrideResolver();
|
||||
this.topDownAnalyzer = new TopDownAnalyzer();
|
||||
this.typeHierarchyResolver = new TypeHierarchyResolver();
|
||||
this.scriptHeaderResolver = new ScriptHeaderResolver();
|
||||
this.varianceChecker = new VarianceChecker(bindingTrace);
|
||||
|
||||
this.resolveSession.setAnnotationResolve(annotationResolver);
|
||||
this.resolveSession.setDescriptorResolver(descriptorResolver);
|
||||
this.resolveSession.setJetImportFactory(jetImportsFactory);
|
||||
this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
this.resolveSession.setScopeProvider(scopeProvider);
|
||||
this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
|
||||
this.resolveSession.setTypeResolver(typeResolver);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
|
||||
this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession);
|
||||
this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
|
||||
this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
|
||||
this.lazyTopDownAnalyzer.setModuleDescriptor(module);
|
||||
this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
|
||||
this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
|
||||
this.lazyTopDownAnalyzer.setTrace(bindingTrace);
|
||||
this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
this.lazyTopDownAnalyzerForTopLevel.setKotlinCodeAnalyzer(resolveSession);
|
||||
this.lazyTopDownAnalyzerForTopLevel.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
|
||||
|
||||
annotationResolver.setCallResolver(callResolver);
|
||||
annotationResolver.setStorageManager(storageManager);
|
||||
annotationResolver.setTypeResolver(typeResolver);
|
||||
@@ -245,8 +248,6 @@ public class InjectorForTopDownAnalyzerForJs {
|
||||
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
|
||||
forLoopConventionsChecker.setProject(project);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
descriptorResolver.setAnnotationResolver(annotationResolver);
|
||||
descriptorResolver.setBuiltIns(kotlinBuiltIns);
|
||||
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
|
||||
@@ -258,11 +259,16 @@ public class InjectorForTopDownAnalyzerForJs {
|
||||
delegatedPropertyResolver.setCallResolver(callResolver);
|
||||
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
|
||||
|
||||
jetImportsFactory.setProject(project);
|
||||
|
||||
scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
|
||||
lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
|
||||
lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
|
||||
|
||||
declarationScopeProvider.setFileScopeProvider(scopeProvider);
|
||||
|
||||
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
|
||||
|
||||
@@ -285,37 +291,12 @@ public class InjectorForTopDownAnalyzerForJs {
|
||||
functionAnalyzerExtension.setTrace(bindingTrace);
|
||||
|
||||
declarationResolver.setAnnotationResolver(annotationResolver);
|
||||
declarationResolver.setDescriptorResolver(descriptorResolver);
|
||||
declarationResolver.setImportsResolver(importsResolver);
|
||||
declarationResolver.setTrace(bindingTrace);
|
||||
|
||||
importsResolver.setImportsFactory(jetImportsFactory);
|
||||
importsResolver.setModuleDescriptor(module);
|
||||
importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
|
||||
importsResolver.setTrace(bindingTrace);
|
||||
|
||||
overloadResolver.setTrace(bindingTrace);
|
||||
|
||||
overrideResolver.setTrace(bindingTrace);
|
||||
|
||||
topDownAnalyzer.setBodyResolver(bodyResolver);
|
||||
topDownAnalyzer.setDeclarationResolver(declarationResolver);
|
||||
topDownAnalyzer.setModuleDescriptor(module);
|
||||
topDownAnalyzer.setOverloadResolver(overloadResolver);
|
||||
topDownAnalyzer.setOverrideResolver(overrideResolver);
|
||||
topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
|
||||
topDownAnalyzer.setVarianceChecker(varianceChecker);
|
||||
|
||||
typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
|
||||
typeHierarchyResolver.setImportsResolver(importsResolver);
|
||||
typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
|
||||
typeHierarchyResolver.setTrace(bindingTrace);
|
||||
|
||||
scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
|
||||
scriptHeaderResolver.setTrace(bindingTrace);
|
||||
|
||||
}
|
||||
|
||||
@PreDestroy
|
||||
@@ -330,4 +311,8 @@ public class InjectorForTopDownAnalyzerForJs {
|
||||
return this.lazyTopDownAnalyzer;
|
||||
}
|
||||
|
||||
public LazyTopDownAnalyzerForTopLevel getLazyTopDownAnalyzerForTopLevel() {
|
||||
return this.lazyTopDownAnalyzerForTopLevel;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -107,7 +107,7 @@ public final class TopDownAnalyzerFacadeForJS {
|
||||
project, topDownAnalysisParameters, trace, module,
|
||||
new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), allFiles));
|
||||
try {
|
||||
injector.getLazyTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, allFiles,
|
||||
injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, allFiles,
|
||||
Collections.<PackageFragmentProvider>emptyList());
|
||||
return AnalysisResult.success(trace.getBindingContext(), module);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user