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

Introduce ModuleContext, ProjectContext and use it some of the APIs

Browse Source
This commit is contained in:
Pavel V. Talanov
2015-05-15 17:17:09 +03:00
parent 9d22a39924
commit 01efbb1502
34 changed files with 450 additions and 574 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt
+2 -2
View File
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
import org.jetbrains.kotlin.config.CompilerConfiguration
import org.jetbrains.kotlin.config.addKotlinSourceRoots
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.context.ProjectContext
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -86,7 +86,7 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
val builtInModule = BuiltinsSourcesModule()
val resolver = JvmAnalyzerFacade.setupResolverForProject(
GlobalContext(), environment.project, listOf(builtInModule),
ProjectContext(environment.project), listOf(builtInModule),
{ ModuleContent(files, GlobalSearchScope.EMPTY_SCOPE) },
platformParameters = JvmPlatformParameters { throw IllegalStateException() }
)
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
+1 -3
View File
@@ -320,11 +320,9 @@ public class KotlinToJVMBytecodeCompiler {
ModuleDescriptorImpl analyzeModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
environment.getProject(),
ContextPackage.GlobalContext(),
ContextPackage.ModuleContext(analyzeModule, environment.getProject()),
environment.getSourceFiles(),
sharedTrace,
analyzeModule,
environment.getConfiguration().get(JVMConfigurationKeys.MODULE_IDS),
environment.getConfiguration().get(JVMConfigurationKeys.INCREMENTAL_CACHE_PROVIDER)
);
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java
+2 -4
View File
@@ -44,7 +44,7 @@ import org.jetbrains.kotlin.codegen.KotlinCodegenFacade;
import org.jetbrains.kotlin.codegen.state.GenerationState;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.context.ContextPackage;
import org.jetbrains.kotlin.context.GlobalContextImpl;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.descriptors.ScriptDescriptor;
import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -110,7 +110,7 @@ public class ReplInterpreter {
this.trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
this.module = TopDownAnalyzerFacadeForJVM.createJavaModule("<repl>");
GlobalContextImpl context = ContextPackage.GlobalContext();
ModuleContext context = ContextPackage.ModuleContext(module, project);
scriptDeclarationFactory = new ScriptMutableDeclarationProviderFactory();
@@ -123,10 +123,8 @@ public class ReplInterpreter {
};
InjectorForReplWithJava injector = new InjectorForReplWithJava(
project,
context,
trace,
module,
scriptDeclarationFactory,
ProjectScope.getAllScope(project),
scopeProvider
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java
+26 -28
View File
@@ -16,13 +16,13 @@
package org.jetbrains.kotlin.di;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import com.intellij.openapi.project.Project;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
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;
@@ -85,13 +85,13 @@ import javax.annotation.PreDestroy;
@SuppressWarnings("all")
public class InjectorForLazyResolveWithJava {
private final ModuleContext moduleContext;
private final KotlinBuiltIns kotlinBuiltIns;
private final ModuleDescriptorImpl moduleDescriptor;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final Project project;
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final BindingTrace bindingTrace;
private final ModuleDescriptorImpl module;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final DeclarationProviderFactory declarationProviderFactory;
private final ResolveSession resolveSession;
private final ScopeProvider scopeProvider;
@@ -149,23 +149,21 @@ public class InjectorForLazyResolveWithJava {
private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
public InjectorForLazyResolveWithJava(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull ModuleContext moduleContext,
@NotNull BindingTrace bindingTrace,
@NotNull ModuleDescriptorImpl module,
@NotNull DeclarationProviderFactory declarationProviderFactory,
@NotNull GlobalSearchScope moduleContentScope,
@NotNull ModuleClassResolver moduleClassResolver
) {
this.project = project;
this.globalContext = globalContext;
this.storageManager = globalContext.getStorageManager();
this.moduleContext = moduleContext;
this.kotlinBuiltIns = moduleContext.getBuiltIns();
this.moduleDescriptor = moduleContext.getModule();
this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
this.project = moduleContext.getProject();
this.storageManager = moduleContext.getStorageManager();
this.bindingTrace = bindingTrace;
this.module = module;
this.kotlinBuiltIns = module.getBuiltIns();
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
this.declarationProviderFactory = declarationProviderFactory;
this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
this.resolveSession = new ResolveSession(project, getModuleContext(), moduleDescriptor, declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.moduleContentScope = moduleContentScope;
this.moduleClassResolver = moduleClassResolver;
@@ -181,9 +179,9 @@ public class InjectorForLazyResolveWithJava {
this.samConversionResolver = SamConversionResolverImpl.INSTANCE$;
this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, moduleClassResolver);
this.reflectionTypes = new ReflectionTypes(getModule());
this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule(), reflectionTypes);
this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, moduleDescriptor, reflectionTypes);
this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, moduleDescriptor);
this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
this.lazyResolveToken = new LazyResolveToken();
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
@@ -200,7 +198,7 @@ public class InjectorForLazyResolveWithJava {
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.dynamicTypesSettings = new DynamicTypesSettings();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
@@ -212,13 +210,13 @@ public class InjectorForLazyResolveWithJava {
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
this.jetImportsFactory = new JetImportsFactory();
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
this.lazyDeclarationResolver = new LazyDeclarationResolver(getModuleContext(), bindingTrace);
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
this.scriptBodyResolver = new ScriptBodyResolver();
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModule(), storageManager, virtualFileFinder, traceBasedErrorReporter);
this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModule(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(moduleDescriptor, storageManager, virtualFileFinder, traceBasedErrorReporter);
this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, moduleDescriptor, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
this.resolveSession.setAnnotationResolve(annotationResolver);
this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -281,7 +279,7 @@ public class InjectorForLazyResolveWithJava {
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setGlobalContext(moduleContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
@@ -334,8 +332,8 @@ public class InjectorForLazyResolveWithJava {
public void destroy() {
}
public ModuleDescriptorImpl getModule() {
return this.module;
public ModuleContext getModuleContext() {
return this.moduleContext;
}
public ResolveSession getResolveSession() {
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java
+27 -29
View File
@@ -16,13 +16,13 @@
package org.jetbrains.kotlin.di;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import com.intellij.openapi.project.Project;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
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;
@@ -96,13 +96,13 @@ import javax.annotation.PreDestroy;
@SuppressWarnings("all")
public class InjectorForReplWithJava {
private final ModuleContext moduleContext;
private final KotlinBuiltIns kotlinBuiltIns;
private final ModuleDescriptorImpl moduleDescriptor;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final Project project;
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final BindingTrace bindingTrace;
private final ModuleDescriptorImpl module;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final DeclarationProviderFactory declarationProviderFactory;
private final ResolveSession resolveSession;
private final ScopeProvider scopeProvider;
@@ -171,23 +171,21 @@ public class InjectorForReplWithJava {
private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
public InjectorForReplWithJava(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull ModuleContext moduleContext,
@NotNull BindingTrace bindingTrace,
@NotNull ModuleDescriptorImpl module,
@NotNull DeclarationProviderFactory declarationProviderFactory,
@NotNull GlobalSearchScope moduleContentScope,
@NotNull AdditionalFileScopeProvider additionalFileScopeProvider
) {
this.project = project;
this.globalContext = globalContext;
this.storageManager = globalContext.getStorageManager();
this.moduleContext = moduleContext;
this.kotlinBuiltIns = moduleContext.getBuiltIns();
this.moduleDescriptor = moduleContext.getModule();
this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
this.project = moduleContext.getProject();
this.storageManager = moduleContext.getStorageManager();
this.bindingTrace = bindingTrace;
this.module = module;
this.kotlinBuiltIns = module.getBuiltIns();
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
this.declarationProviderFactory = declarationProviderFactory;
this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
this.resolveSession = new ResolveSession(project, getModuleContext(), moduleDescriptor, declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.moduleContentScope = moduleContentScope;
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
@@ -205,12 +203,12 @@ public class InjectorForReplWithJava {
this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
this.singleModuleClassResolver = new SingleModuleClassResolver();
this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver);
this.reflectionTypes = new ReflectionTypes(getModule());
this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule(), reflectionTypes);
this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, moduleDescriptor, reflectionTypes);
this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, moduleDescriptor);
this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModule(), storageManager, virtualFileFinder, traceBasedErrorReporter);
this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModule(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(moduleDescriptor, storageManager, virtualFileFinder, traceBasedErrorReporter);
this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, moduleDescriptor, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
@@ -228,7 +226,7 @@ public class InjectorForReplWithJava {
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.typeLazinessToken = new TypeLazinessToken();
this.dynamicTypesSettings = new DynamicTypesSettings();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
@@ -240,7 +238,7 @@ public class InjectorForReplWithJava {
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
this.jetImportsFactory = new JetImportsFactory();
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
this.lazyDeclarationResolver = new LazyDeclarationResolver(getModuleContext(), bindingTrace);
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
this.scriptBodyResolver = new ScriptBodyResolver();
this.bodyResolver = new BodyResolver();
@@ -271,7 +269,7 @@ public class InjectorForReplWithJava {
this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
this.lazyTopDownAnalyzer.setModuleDescriptor(module);
this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
@@ -331,7 +329,7 @@ public class InjectorForReplWithJava {
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setGlobalContext(moduleContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
@@ -411,8 +409,8 @@ public class InjectorForReplWithJava {
public void destroy() {
}
public ModuleDescriptorImpl getModule() {
return this.module;
public ModuleContext getModuleContext() {
return this.moduleContext;
}
public ResolveSession getResolveSession() {
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java
+27 -29
View File
@@ -16,13 +16,13 @@
package org.jetbrains.kotlin.di;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import com.intellij.openapi.project.Project;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
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;
@@ -96,13 +96,13 @@ import javax.annotation.PreDestroy;
@SuppressWarnings("all")
public class InjectorForTopDownAnalyzerForJvm {
private final ModuleContext moduleContext;
private final KotlinBuiltIns kotlinBuiltIns;
private final ModuleDescriptorImpl moduleDescriptor;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final Project project;
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final BindingTrace bindingTrace;
private final ModuleDescriptorImpl module;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final DeclarationProviderFactory declarationProviderFactory;
private final ResolveSession resolveSession;
private final ScopeProvider scopeProvider;
@@ -171,22 +171,20 @@ public class InjectorForTopDownAnalyzerForJvm {
private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
public InjectorForTopDownAnalyzerForJvm(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull ModuleContext moduleContext,
@NotNull BindingTrace bindingTrace,
@NotNull ModuleDescriptorImpl module,
@NotNull DeclarationProviderFactory declarationProviderFactory,
@NotNull GlobalSearchScope moduleContentScope
) {
this.project = project;
this.globalContext = globalContext;
this.storageManager = globalContext.getStorageManager();
this.moduleContext = moduleContext;
this.kotlinBuiltIns = moduleContext.getBuiltIns();
this.moduleDescriptor = moduleContext.getModule();
this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
this.project = moduleContext.getProject();
this.storageManager = moduleContext.getStorageManager();
this.bindingTrace = bindingTrace;
this.module = module;
this.kotlinBuiltIns = module.getBuiltIns();
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
this.declarationProviderFactory = declarationProviderFactory;
this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
this.resolveSession = new ResolveSession(project, getModuleContext(), moduleDescriptor, declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.moduleContentScope = moduleContentScope;
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
@@ -204,12 +202,12 @@ public class InjectorForTopDownAnalyzerForJvm {
this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
this.singleModuleClassResolver = new SingleModuleClassResolver();
this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver);
this.reflectionTypes = new ReflectionTypes(getModule());
this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule(), reflectionTypes);
this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, moduleDescriptor, reflectionTypes);
this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, moduleDescriptor);
this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModule(), storageManager, virtualFileFinder, traceBasedErrorReporter);
this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModule(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(moduleDescriptor, storageManager, virtualFileFinder, traceBasedErrorReporter);
this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, moduleDescriptor, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
@@ -226,7 +224,7 @@ public class InjectorForTopDownAnalyzerForJvm {
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.typeLazinessToken = new TypeLazinessToken();
this.dynamicTypesSettings = new DynamicTypesSettings();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
@@ -238,7 +236,7 @@ public class InjectorForTopDownAnalyzerForJvm {
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
this.jetImportsFactory = new JetImportsFactory();
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
this.lazyDeclarationResolver = new LazyDeclarationResolver(getModuleContext(), bindingTrace);
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
this.scriptBodyResolver = new ScriptBodyResolver();
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
@@ -270,7 +268,7 @@ public class InjectorForTopDownAnalyzerForJvm {
this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
this.lazyTopDownAnalyzer.setModuleDescriptor(module);
this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
@@ -330,7 +328,7 @@ public class InjectorForTopDownAnalyzerForJvm {
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setGlobalContext(moduleContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
@@ -410,8 +408,8 @@ public class InjectorForTopDownAnalyzerForJvm {
public void destroy() {
}
public ModuleDescriptorImpl getModule() {
return this.module;
public ModuleContext getModuleContext() {
return this.moduleContext;
}
public ResolveSession getResolveSession() {
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt
+20 -27
View File
@@ -16,29 +16,22 @@
package org.jetbrains.kotlin.resolve.jvm
import org.jetbrains.kotlin.analyzer.AnalyzerFacade
import org.jetbrains.kotlin.analyzer.ResolverForModule
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.analyzer.PlatformAnalysisParameters
import org.jetbrains.kotlin.analyzer.ResolverForProject
import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
import org.jetbrains.kotlin.load.java.structure.JavaClass
import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.analyzer.ModuleInfo
import org.jetbrains.kotlin.analyzer.ModuleContent
import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava
import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
import com.intellij.psi.search.GlobalSearchScope
import java.util.ArrayList
import org.jetbrains.kotlin.analyzer.*
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava
import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
import kotlin.platform.platformStatic
import com.intellij.openapi.module.Module
import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
import org.jetbrains.kotlin.load.java.structure.JavaClass
import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
import org.jetbrains.kotlin.psi.JetFile
import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
import java.util.ArrayList
import kotlin.platform.platformStatic
public class JvmResolverForModule(
override val lazyResolveSession: ResolveSession,
@@ -53,17 +46,16 @@ public class JvmPlatformParameters(
public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatformParameters> {
override fun <M : ModuleInfo> createResolverForModule(
moduleInfo: M,
project: Project,
globalContext: GlobalContext,
moduleDescriptor: ModuleDescriptorImpl,
moduleContext: ModuleContext,
moduleContent: ModuleContent,
platformParameters: JvmPlatformParameters,
resolverForProject: ResolverForProject<M, JvmResolverForModule>
): JvmResolverForModule {
val (syntheticFiles, moduleContentScope) = moduleContent
val project = moduleContext.project
val filesToAnalyze = getAllFilesToAnalyze(project, moduleInfo, syntheticFiles)
val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
project, globalContext.storageManager, filesToAnalyze,
project, moduleContext.storageManager, filesToAnalyze,
if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope
)
@@ -72,16 +64,17 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
resolverForProject.resolverForModule(moduleInfo as M).javaDescriptorResolver
}
val injector = InjectorForLazyResolveWithJava(
project, globalContext,
moduleContext,
CodeAnalyzerInitializer.getInstance(project).createTrace(),
moduleDescriptor, declarationProviderFactory,
moduleContentScope, moduleClassResolver
declarationProviderFactory,
moduleContentScope,
moduleClassResolver
)
val resolveSession = injector.getResolveSession()!!
val javaDescriptorResolver = injector.getJavaDescriptorResolver()!!
val providersForModule = listOf(resolveSession.getPackageFragmentProvider(), javaDescriptorResolver.packageFragmentProvider)
moduleDescriptor.initialize(CompositePackageFragmentProvider(providersForModule))
moduleContext.module.initialize(CompositePackageFragmentProvider(providersForModule))
return JvmResolverForModule(resolveSession, javaDescriptorResolver)
}
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java
+16 -26
View File
@@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.analyzer.AnalysisResult;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -66,57 +66,47 @@ public enum TopDownAnalyzerFacadeForJVM {
return list;
}
private TopDownAnalyzerFacadeForJVM() {
}
@NotNull
public static AnalysisResult analyzeFilesWithJavaIntegrationNoIncremental(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull ModuleContext moduleContext,
@NotNull Collection<JetFile> files,
@NotNull BindingTrace trace,
@NotNull TopDownAnalysisMode topDownAnalysisMode,
@NotNull ModuleDescriptorImpl module
@NotNull TopDownAnalysisMode topDownAnalysisMode
) {
return analyzeFilesWithJavaIntegration(project, globalContext, files, trace, topDownAnalysisMode, module, null, null);
return analyzeFilesWithJavaIntegration(moduleContext, files, trace, topDownAnalysisMode, null, null);
}
@NotNull
public static AnalysisResult analyzeFilesWithJavaIntegrationWithCustomContext(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull ModuleContext moduleContext,
@NotNull Collection<JetFile> files,
@NotNull BindingTrace trace,
@NotNull ModuleDescriptorImpl module,
@Nullable List<String> moduleIds,
@Nullable IncrementalCacheProvider incrementalCacheProvider
) {
return analyzeFilesWithJavaIntegration(
project, globalContext, files, trace, TopDownAnalysisMode.TopLevelDeclarations, module,
moduleIds, incrementalCacheProvider);
moduleContext, files, trace, TopDownAnalysisMode.TopLevelDeclarations, moduleIds, incrementalCacheProvider
);
}
@NotNull
private static AnalysisResult analyzeFilesWithJavaIntegration(
Project project,
@NotNull GlobalContext globalContext,
Collection<JetFile> files,
BindingTrace trace,
TopDownAnalysisMode topDownAnalysisMode,
ModuleDescriptorImpl module,
@NotNull ModuleContext moduleContext,
@NotNull Collection<JetFile> files,
@NotNull BindingTrace trace,
@NotNull TopDownAnalysisMode topDownAnalysisMode,
@Nullable List<String> moduleIds,
@Nullable IncrementalCacheProvider incrementalCacheProvider
) {
Project project = moduleContext.getProject();
List<JetFile> allFiles = JvmAnalyzerFacade.getAllFilesToAnalyze(project, null, files);
FileBasedDeclarationProviderFactory providerFactory =
new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), allFiles);
new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles);
InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
project,
globalContext,
moduleContext,
trace,
module,
providerFactory,
GlobalSearchScope.allScope(project)
);
@@ -130,7 +120,7 @@ public enum TopDownAnalyzerFacadeForJVM {
additionalProviders.add(
new IncrementalPackageFragmentProvider(
files, module, globalContext.getStorageManager(),
files, moduleContext.getModule(), moduleContext.getStorageManager(),
injector.getDeserializationComponentsForJava().getComponents(),
incrementalCache, moduleId
)
@@ -140,7 +130,7 @@ public enum TopDownAnalyzerFacadeForJVM {
additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisMode, allFiles, additionalProviders);
return AnalysisResult.success(trace.getBindingContext(), module);
return AnalysisResult.success(trace.getBindingContext(), moduleContext.getModule());
}
finally {
injector.destroy();
compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt
+16 -18
View File
@@ -16,19 +16,20 @@
package org.jetbrains.kotlin.analyzer
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import java.util.HashMap
import org.jetbrains.kotlin.resolve.ImportPath
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import java.util.ArrayList
import org.jetbrains.kotlin.psi.JetFile
import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.context.ProjectContext
import org.jetbrains.kotlin.context.withModule
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
import org.jetbrains.kotlin.psi.JetFile
import org.jetbrains.kotlin.resolve.ImportPath
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import java.util.ArrayList
import java.util.HashMap
import kotlin.properties.Delegates
public trait ResolverForModule {
@@ -118,8 +119,7 @@ public trait ModuleInfo {
//TODO: (module refactoring) extract project context
public trait AnalyzerFacade<A : ResolverForModule, in P : PlatformAnalysisParameters> {
public fun <M : ModuleInfo> setupResolverForProject(
globalContext: GlobalContext,
project: Project,
projectContext: ProjectContext,
modules: Collection<M>,
modulesContent: (M) -> ModuleContent,
platformParameters: P,
@@ -173,7 +173,7 @@ public trait AnalyzerFacade<A : ResolverForModule, in P : PlatformAnalysisParame
module ->
val descriptor = resolverForProject.descriptorForModule(module)
val resolverForModule = createResolverForModule(
module, project, globalContext, descriptor, modulesContent(module), platformParameters, resolverForProject
module, projectContext.withModule(descriptor), modulesContent(module), platformParameters, resolverForProject
)
assert(descriptor.isInitialized, "ModuleDescriptorImpl#initialize() should be called in createResolverForModule")
resolverForProject.resolverByModuleDescriptor[descriptor] = resolverForModule
@@ -186,9 +186,7 @@ public trait AnalyzerFacade<A : ResolverForModule, in P : PlatformAnalysisParame
protected fun <M : ModuleInfo> createResolverForModule(
moduleInfo: M,
project: Project,
globalContext: GlobalContext,
moduleDescriptor: ModuleDescriptorImpl,
moduleContext: ModuleContext,
moduleContent: ModuleContent,
platformParameters: P,
resolverForProject: ResolverForProject<M, A>
compiler/frontend/src/org/jetbrains/kotlin/context/context.kt
+36 -1
View File
@@ -16,15 +16,33 @@
package org.jetbrains.kotlin.context
import org.jetbrains.kotlin.storage.StorageManager
import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
import org.jetbrains.kotlin.storage.ExceptionTracker
import org.jetbrains.kotlin.storage.LockBasedStorageManager
import org.jetbrains.kotlin.storage.StorageManager
public trait GlobalContext {
public val storageManager: StorageManager
public val exceptionTracker: ExceptionTracker
}
public trait ProjectContext : GlobalContext {
public val project: Project
}
public trait ModuleContext : ProjectContext {
public val module: ModuleDescriptorImpl
public val platformToKotlinClassMap: PlatformToKotlinClassMap
get() = module.platformToKotlinClassMap
public val builtIns: KotlinBuiltIns
get() = module.builtIns
}
public open class SimpleGlobalContext(
override val storageManager: StorageManager,
override val exceptionTracker: ExceptionTracker
@@ -37,11 +55,28 @@ public open class GlobalContextImpl(
override val storageManager: LockBasedStorageManager = super.storageManager as LockBasedStorageManager
}
public class ProjectContextImpl(
override val project: Project,
private val globalContext: GlobalContext
) : ProjectContext, GlobalContext by globalContext
public class ModuleContextImpl(
override val module: ModuleDescriptorImpl,
projectContext: ProjectContext
) : ModuleContext, ProjectContext by projectContext
public fun GlobalContext(): GlobalContextImpl {
val tracker = ExceptionTracker()
return GlobalContextImpl(LockBasedStorageManager.createWithExceptionHandling(tracker), tracker)
}
public fun ProjectContext(project: Project): ProjectContext = ProjectContextImpl(project, GlobalContext())
public fun ModuleContext(module: ModuleDescriptorImpl, project: Project): ModuleContext =
ModuleContextImpl(module, ProjectContext(project))
public fun GlobalContext.withProject(project: Project): ProjectContext = ProjectContextImpl(project, this)
public fun ProjectContext.withModule(module: ModuleDescriptorImpl): ModuleContext = ModuleContextImpl(module, this)
deprecated("Used temporarily while we are in transition from to lazy resolve")
public open class TypeLazinessToken {
deprecated("Used temporarily while we are in transition from to lazy resolve")
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java
+27 -53
View File
@@ -17,59 +17,35 @@
package org.jetbrains.kotlin.di;
import com.intellij.openapi.project.Project;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.storage.StorageManager;
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.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.BodyResolver;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
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.TypeLazinessToken;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
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.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.ScriptBodyResolver;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.context.TypeLazinessToken;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.*;
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.resolve.calls.*;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.*;
import javax.annotation.PreDestroy;
/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
@SuppressWarnings("all")
public class InjectorForBodyResolve {
private final ModuleContext moduleContext;
private final KotlinBuiltIns kotlinBuiltIns;
private final ModuleDescriptorImpl moduleDescriptor;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final Project project;
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final BindingTrace bindingTrace;
private final ModuleDescriptor moduleDescriptor;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final AdditionalCheckerProvider additionalCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final StatementFilter statementFilter;
@@ -105,20 +81,18 @@ public class InjectorForBodyResolve {
private final ScriptBodyResolver scriptBodyResolver;
public InjectorForBodyResolve(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull ModuleContext moduleContext,
@NotNull BindingTrace bindingTrace,
@NotNull ModuleDescriptor moduleDescriptor,
@NotNull AdditionalCheckerProvider additionalCheckerProvider,
@NotNull StatementFilter statementFilter
) {
this.project = project;
this.globalContext = globalContext;
this.storageManager = globalContext.getStorageManager();
this.moduleContext = moduleContext;
this.kotlinBuiltIns = moduleContext.getBuiltIns();
this.moduleDescriptor = moduleContext.getModule();
this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
this.project = moduleContext.getProject();
this.storageManager = moduleContext.getStorageManager();
this.bindingTrace = bindingTrace;
this.moduleDescriptor = moduleDescriptor;
this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
this.additionalCheckerProvider = additionalCheckerProvider;
this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
this.statementFilter = statementFilter;
@@ -194,7 +168,7 @@ public class InjectorForBodyResolve {
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setGlobalContext(moduleContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java
+45 -77
View File
@@ -17,79 +17,46 @@
package org.jetbrains.kotlin.di;
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.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
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.LazyTopDownAnalyzer;
import org.jetbrains.kotlin.resolve.BodyResolver;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
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.TypeLazinessToken;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
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.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.ScriptBodyResolver;
import org.jetbrains.kotlin.resolve.DeclarationResolver;
import org.jetbrains.kotlin.resolve.OverloadResolver;
import org.jetbrains.kotlin.resolve.OverrideResolver;
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.context.TypeLazinessToken;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.*;
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.resolve.calls.*;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider;
import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.*;
import javax.annotation.PreDestroy;
/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
@SuppressWarnings("all")
public class InjectorForLazyBodyResolve {
private final ModuleContext moduleContext;
private final KotlinBuiltIns kotlinBuiltIns;
private final ModuleDescriptorImpl moduleDescriptor;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final Project project;
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final KotlinCodeAnalyzer analyzer;
private final ModuleDescriptor moduleDescriptor;
private final ScopeProvider scopeProvider;
private final FileScopeProvider fileScopeProvider;
private final BindingTrace bindingTrace;
private final AdditionalCheckerProvider additionalCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final DynamicTypesSettings dynamicTypesSettings;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
private final AdditionalFileScopeProvider additionalFileScopeProvider;
private final DeclarationScopeProviderImpl declarationScopeProvider;
private final LazyDeclarationResolver lazyDeclarationResolver;
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
private final BodyResolver bodyResolver;
private final AnnotationResolver annotationResolver;
@@ -122,34 +89,33 @@ public class InjectorForLazyBodyResolve {
private final FunctionAnalyzerExtension functionAnalyzerExtension;
private final ScriptBodyResolver scriptBodyResolver;
private final DeclarationResolver declarationResolver;
private final DeclarationScopeProviderImpl declarationScopeProvider;
private final LazyDeclarationResolver lazyDeclarationResolver;
private final OverloadResolver overloadResolver;
private final OverrideResolver overrideResolver;
private final VarianceChecker varianceChecker;
public InjectorForLazyBodyResolve(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull ModuleContext moduleContext,
@NotNull KotlinCodeAnalyzer analyzer,
@NotNull FileScopeProvider fileScopeProvider,
@NotNull BindingTrace bindingTrace,
@NotNull AdditionalCheckerProvider additionalCheckerProvider,
@NotNull DynamicTypesSettings dynamicTypesSettings
) {
this.project = project;
this.globalContext = globalContext;
this.storageManager = globalContext.getStorageManager();
this.moduleContext = moduleContext;
this.kotlinBuiltIns = moduleContext.getBuiltIns();
this.moduleDescriptor = moduleContext.getModule();
this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
this.project = moduleContext.getProject();
this.storageManager = moduleContext.getStorageManager();
this.analyzer = analyzer;
this.moduleDescriptor = analyzer.getModuleDescriptor();
this.scopeProvider = analyzer.getScopeProvider();
this.fileScopeProvider = fileScopeProvider;
this.bindingTrace = bindingTrace;
this.additionalCheckerProvider = additionalCheckerProvider;
this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
this.dynamicTypesSettings = dynamicTypesSettings;
this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
this.bodyResolver = new BodyResolver();
this.annotationResolver = new AnnotationResolver();
@@ -182,6 +148,8 @@ public class InjectorForLazyBodyResolve {
this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
this.scriptBodyResolver = new ScriptBodyResolver();
this.declarationResolver = new DeclarationResolver();
this.lazyDeclarationResolver = new LazyDeclarationResolver(moduleContext, bindingTrace);
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
this.overloadResolver = new OverloadResolver();
this.overrideResolver = new OverrideResolver();
this.varianceChecker = new VarianceChecker(bindingTrace);
@@ -189,15 +157,10 @@ public class InjectorForLazyBodyResolve {
this.lazyTopDownAnalyzerForTopLevel.setKotlinCodeAnalyzer(analyzer);
this.lazyTopDownAnalyzerForTopLevel.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
declarationScopeProvider.setFileScopeProvider(scopeProvider);
lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
lazyDeclarationResolver.setTopLevelDescriptorProvider(analyzer);
lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
lazyTopDownAnalyzer.setFileScopeProvider(fileScopeProvider);
lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
@@ -247,7 +210,7 @@ public class InjectorForLazyBodyResolve {
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setGlobalContext(moduleContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
@@ -292,6 +255,11 @@ public class InjectorForLazyBodyResolve {
declarationResolver.setAnnotationResolver(annotationResolver);
declarationResolver.setTrace(bindingTrace);
declarationScopeProvider.setFileScopeProvider(fileScopeProvider);
lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
lazyDeclarationResolver.setTopLevelDescriptorProvider(analyzer);
overloadResolver.setTrace(bindingTrace);
overrideResolver.setTrace(bindingTrace);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java
+34 -67
View File
@@ -17,69 +17,38 @@
package org.jetbrains.kotlin.di;
import com.intellij.openapi.project.Project;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.storage.StorageManager;
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.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorHolder;
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;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
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.TypeLazinessToken;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
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.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.ScriptBodyResolver;
import org.jetbrains.kotlin.resolve.DeclarationResolver;
import org.jetbrains.kotlin.resolve.OverloadResolver;
import org.jetbrains.kotlin.resolve.OverrideResolver;
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.context.TypeLazinessToken;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.*;
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.resolve.calls.*;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider;
import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.*;
import javax.annotation.PreDestroy;
/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
@SuppressWarnings("all")
public class InjectorForLazyLocalClassifierAnalyzer {
private final ModuleContext moduleContext;
private final KotlinBuiltIns kotlinBuiltIns;
private final ModuleDescriptorImpl moduleDescriptor;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final Project project;
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final BindingTrace bindingTrace;
private final ModuleDescriptor module;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final AdditionalCheckerProvider additionalCheckerProvider;
private final SymbolUsageValidator symbolUsageValidator;
private final DynamicTypesSettings dynamicTypesSettings;
@@ -125,21 +94,19 @@ public class InjectorForLazyLocalClassifierAnalyzer {
private final VarianceChecker varianceChecker;
public InjectorForLazyLocalClassifierAnalyzer(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull ModuleContext moduleContext,
@NotNull BindingTrace bindingTrace,
@NotNull ModuleDescriptor module,
@NotNull AdditionalCheckerProvider additionalCheckerProvider,
@NotNull DynamicTypesSettings dynamicTypesSettings,
@NotNull LocalClassDescriptorHolder localClassDescriptorHolder
) {
this.project = project;
this.globalContext = globalContext;
this.storageManager = globalContext.getStorageManager();
this.moduleContext = moduleContext;
this.kotlinBuiltIns = moduleContext.getBuiltIns();
this.moduleDescriptor = moduleContext.getModule();
this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
this.project = moduleContext.getProject();
this.storageManager = moduleContext.getStorageManager();
this.bindingTrace = bindingTrace;
this.module = module;
this.kotlinBuiltIns = module.getBuiltIns();
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
this.additionalCheckerProvider = additionalCheckerProvider;
this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
this.dynamicTypesSettings = dynamicTypesSettings;
@@ -147,7 +114,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
this.noTopLevelDescriptorProvider = NoTopLevelDescriptorProvider.INSTANCE$;
this.noFileScopeProvider = NoFileScopeProvider.INSTANCE$;
this.localLazyDeclarationResolver = new LocalLazyDeclarationResolver(globalContext, bindingTrace, localClassDescriptorHolder);
this.localLazyDeclarationResolver = new LocalLazyDeclarationResolver(moduleContext, bindingTrace, localClassDescriptorHolder);
this.declarationScopeProviderForLocalClassifierAnalyzer = new DeclarationScopeProviderForLocalClassifierAnalyzer(localLazyDeclarationResolver, localClassDescriptorHolder);
this.bodyResolver = new BodyResolver();
this.annotationResolver = new AnnotationResolver();
@@ -162,13 +129,13 @@ public class InjectorForLazyLocalClassifierAnalyzer {
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
this.typeLazinessToken = new TypeLazinessToken();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
this.reflectionTypes = new ReflectionTypes(module);
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.valueParameterResolver = new ValueParameterResolver(additionalCheckerProvider, expressionTypingServices);
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
@@ -189,7 +156,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer);
this.lazyTopDownAnalyzer.setFileScopeProvider(noFileScopeProvider);
this.lazyTopDownAnalyzer.setLazyDeclarationResolver(localLazyDeclarationResolver);
this.lazyTopDownAnalyzer.setModuleDescriptor(module);
this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
@@ -242,7 +209,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setGlobalContext(moduleContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java
+32 -53
View File
@@ -17,60 +17,41 @@
package org.jetbrains.kotlin.di;
import com.intellij.openapi.project.Project;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.context.LazyResolveToken;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.psi.JetImportsFactory;
import org.jetbrains.kotlin.resolve.*;
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.resolve.calls.*;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
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;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
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.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
import org.jetbrains.kotlin.builtins.ReflectionTypes;
import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
import org.jetbrains.kotlin.resolve.StatementFilter;
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.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 org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.*;
import javax.annotation.PreDestroy;
/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
@SuppressWarnings("all")
public class InjectorForLazyResolve {
private final Project project;
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final ModuleDescriptorImpl moduleDescriptor;
private final ModuleContext moduleContext;
private final KotlinBuiltIns kotlinBuiltIns;
private final ModuleDescriptorImpl moduleDescriptor;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final Project project;
private final StorageManager storageManager;
private final DeclarationProviderFactory declarationProviderFactory;
private final BindingTrace bindingTrace;
private final AdditionalCheckerProvider additionalCheckerProvider;
@@ -109,26 +90,24 @@ public class InjectorForLazyResolve {
private final AdditionalFileScopeProvider additionalFileScopeProvider;
public InjectorForLazyResolve(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull ModuleDescriptorImpl moduleDescriptor,
@NotNull ModuleContext moduleContext,
@NotNull DeclarationProviderFactory declarationProviderFactory,
@NotNull BindingTrace bindingTrace,
@NotNull AdditionalCheckerProvider additionalCheckerProvider,
@NotNull DynamicTypesSettings dynamicTypesSettings
) {
this.project = project;
this.globalContext = globalContext;
this.storageManager = globalContext.getStorageManager();
this.moduleDescriptor = moduleDescriptor;
this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
this.moduleContext = moduleContext;
this.kotlinBuiltIns = moduleContext.getBuiltIns();
this.moduleDescriptor = moduleContext.getModule();
this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
this.project = moduleContext.getProject();
this.storageManager = moduleContext.getStorageManager();
this.declarationProviderFactory = declarationProviderFactory;
this.bindingTrace = bindingTrace;
this.additionalCheckerProvider = additionalCheckerProvider;
this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
this.dynamicTypesSettings = dynamicTypesSettings;
this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
this.resolveSession = new ResolveSession(project, moduleContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.lazyResolveToken = new LazyResolveToken();
this.annotationResolver = new AnnotationResolver();
@@ -155,7 +134,7 @@ public class InjectorForLazyResolve {
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
this.jetImportsFactory = new JetImportsFactory();
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
this.lazyDeclarationResolver = new LazyDeclarationResolver(moduleContext, bindingTrace);
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
this.scriptBodyResolver = new ScriptBodyResolver();
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
@@ -202,7 +181,7 @@ public class InjectorForLazyResolve {
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setGlobalContext(moduleContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
+7 -5
View File
@@ -19,9 +19,12 @@ package org.jetbrains.kotlin.types.expressions
import com.intellij.psi.PsiElement
import com.intellij.psi.util.PsiTreeUtil
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.context.withModule
import org.jetbrains.kotlin.context.withProject
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.psi.JetClassOrObject
@@ -59,12 +62,11 @@ public class LocalClassifierAnalyzer(
additionalCheckerProvider: AdditionalCheckerProvider,
dynamicTypesSettings: DynamicTypesSettings
) {
val moduleDescriptor = DescriptorUtils.getContainingModule(containingDeclaration)
val module = DescriptorUtils.getContainingModule(containingDeclaration)
val moduleContext = globalContext.withProject(classOrObject.getProject()).withModule(module as ModuleDescriptorImpl)
val injector = InjectorForLazyLocalClassifierAnalyzer(
classOrObject.getProject(),
globalContext,
moduleContext,
context.trace,
moduleDescriptor,
additionalCheckerProvider,
dynamicTypesSettings,
LocalClassDescriptorHolder(
@@ -73,7 +75,7 @@ public class LocalClassifierAnalyzer(
containingDeclaration,
globalContext.storageManager,
context,
moduleDescriptor,
module,
descriptorResolver,
funcionDescriptorResolver,
typeResolver,
compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java
+8 -5
View File
@@ -29,6 +29,7 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.context.SimpleGlobalContext;
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
@@ -59,6 +60,8 @@ import org.jetbrains.kotlin.utils.UtilsPackage;
import java.io.File;
import java.util.*;
import static org.jetbrains.kotlin.context.ContextPackage.withModule;
import static org.jetbrains.kotlin.context.ContextPackage.withProject;
import static org.jetbrains.kotlin.diagnostics.Errors.*;
import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.RECURSIVE;
import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.RECURSIVE_ALL;
@@ -144,7 +147,8 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
StringBuilder actualText = new StringBuilder();
for (TestFile testFile : testFiles) {
ok &= testFile.getActualText(moduleBindings.get(testFile.getModule()), actualText, shouldSkipJvmSignatureDiagnostics(groupedByModule));
ok &= testFile.getActualText(moduleBindings.get(testFile.getModule()), actualText,
shouldSkipJvmSignatureDiagnostics(groupedByModule));
}
Throwable exceptionFromDynamicCallDescriptorsValidation = null;
@@ -223,14 +227,14 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
ModuleDescriptorImpl module,
BindingTrace moduleTrace
) {
ModuleContext moduleContext = withModule(withProject(context, getProject()), module);
// New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
// albeit with same class names
TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
getProject(),
context,
moduleContext,
jetFiles,
moduleTrace,
module,
null,
null
);
@@ -378,7 +382,6 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
if (diagnosticsStoringResolvedCalls1.contains(factory)) {
assertResolvedCallsAreCompleted(
diagnostic, DiagnosticFactory.cast(diagnostic, diagnosticsStoringResolvedCalls1).getA());
}
//noinspection SuspiciousMethodCalls
if (diagnosticsStoringResolvedCalls2.contains(factory)) {
compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java
+3 -4
View File
@@ -151,12 +151,11 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
environment.getProject(),
ContextPackage.GlobalContext(),
ContextPackage.ModuleContext(module, environment.getProject()),
environment.getSourceFiles(),
trace,
TopDownAnalysisMode.TopLevelDeclarations,
module);
TopDownAnalysisMode.TopLevelDeclarations
);
PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
assert packageView != null : "Test package not found";
compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt
+2 -2
View File
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoots
import org.jetbrains.kotlin.config.CompilerConfiguration
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.context.ProjectContext
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
@@ -57,7 +57,7 @@ public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() {
val environment = createEnvironment(moduleDirs)
val modules = setupModules(environment, moduleDirs)
val resolverForProject = JvmAnalyzerFacade.setupResolverForProject(
GlobalContext(), environment.project, modules,
ProjectContext(environment.project), modules,
{ m -> ModuleContent(m.kotlinFiles, m.javaFilesScope) },
JvmPlatformParameters {
javaClass ->
compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt
+18 -18
View File
@@ -16,28 +16,28 @@
package org.jetbrains.kotlin.renderer
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import com.intellij.openapi.editor.impl.DocumentImpl
import org.jetbrains.kotlin.test.JetTestUtils
import java.util.ArrayList
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
import org.jetbrains.kotlin.test.ConfigurationKind
import com.intellij.openapi.util.io.FileUtil
import com.intellij.testFramework.UsefulTestCase
import java.io.File
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.di.InjectorForLazyResolve
import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import org.jetbrains.kotlin.descriptors.PropertyDescriptor
import org.jetbrains.kotlin.di.InjectorForLazyResolve
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment
import com.intellij.openapi.util.io.FileUtil
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
import org.jetbrains.kotlin.test.ConfigurationKind
import org.jetbrains.kotlin.test.JetTestUtils
import org.jetbrains.kotlin.types.DynamicTypesSettings
import java.io.File
import java.util.ArrayList
public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
protected open fun getDescriptor(declaration: JetDeclaration, resolveSession: ResolveSession): DeclarationDescriptor {
@@ -49,11 +49,11 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
val psiFile = JetPsiFactory(getProject()).createFile(fileText)
val lazyModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule()
val globalContext = GlobalContext()
val moduleContext = ModuleContext(lazyModule, getProject())
val resolveSession = InjectorForLazyResolve(
getProject(), globalContext, lazyModule,
FileBasedDeclarationProviderFactory(globalContext.storageManager, listOf(psiFile)),
moduleContext,
FileBasedDeclarationProviderFactory(moduleContext.storageManager, listOf(psiFile)),
CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
KotlinJvmCheckerProvider, DynamicTypesSettings()).getResolveSession()
compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java
+1 -1
View File
@@ -78,6 +78,6 @@ public class JvmResolveUtil {
BindingTrace trace = new CliLightClassGenerationSupport.CliBindingTrace();
return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
project, ContextPackage.GlobalContext(), files, trace, module, null, null);
ContextPackage.ModuleContext(module, project), files, trace, null, null);
}
}
compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java
+1 -1
View File
@@ -56,7 +56,7 @@ public class LazyResolveTestUtil {
ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
project, ContextPackage.GlobalContext(), sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations, module
ContextPackage.ModuleContext(module, project), sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations
);
return module;
compiler/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtil.kt
+8 -8
View File
@@ -17,24 +17,24 @@
package org.jetbrains.kotlin.resolve.lazy
import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.psi.JetFile
import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
import org.jetbrains.kotlin.analyzer.ModuleInfo
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
import org.jetbrains.kotlin.analyzer.ModuleContent
import org.jetbrains.kotlin.analyzer.ModuleInfo
import org.jetbrains.kotlin.context.ProjectContext
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.JetFile
import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
public fun createResolveSessionForFiles(
project: Project,
syntheticFiles: Collection<JetFile>,
addBuiltIns: Boolean
): ResolveSession {
val globalContext = GlobalContext()
val projectContext = ProjectContext(project)
val testModule = TestModule(addBuiltIns)
val resolverForProject = JvmAnalyzerFacade.setupResolverForProject(
globalContext, project, listOf(testModule),
projectContext, listOf(testModule),
{ ModuleContent(syntheticFiles, GlobalSearchScope.allScope(project)) },
JvmPlatformParameters { testModule }
)
compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt
+4 -4
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm
import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
import org.jetbrains.kotlin.load.java.JvmAnnotationNames
@@ -54,11 +54,11 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
EnvironmentConfigFiles.JVM_CONFIG_FILES
)
val module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule()
val globalContext = GlobalContext()
val providerFactory = FileBasedDeclarationProviderFactory(globalContext.storageManager, emptyList())
val moduleContext = ModuleContext(module, environment.project)
val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, emptyList())
val injector = InjectorForTopDownAnalyzerForJvm(
environment.project, globalContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), module,
moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
providerFactory, GlobalSearchScope.allScope(environment.project)
)
module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider)
compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java
+5 -11
View File
@@ -20,17 +20,13 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.context.ContextPackage;
import org.jetbrains.kotlin.context.GlobalContextImpl;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.di.InjectorForLazyResolve;
import org.jetbrains.kotlin.di.InjectorForTests;
import org.jetbrains.kotlin.psi.*;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.BindingContext;
import org.jetbrains.kotlin.resolve.BindingTraceContext;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.resolve.*;
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
@@ -102,12 +98,10 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
}
private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, JetClass aClass) {
GlobalContextImpl globalContext = ContextPackage.GlobalContext();
ModuleContext moduleContext = ContextPackage.ModuleContext(root, getProject());
ResolveSession resolveSession = new InjectorForLazyResolve(
getProject(),
globalContext,
root,
new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(),
moduleContext,
new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(),
Collections.singleton(aClass.getContainingJetFile())),
new BindingTraceContext(),
AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt
+8 -18
View File
@@ -20,8 +20,8 @@ import com.intellij.openapi.project.Project
import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.context.LazyResolveToken
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.generators.di.*
import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
@@ -82,10 +82,8 @@ public fun createInjectorGenerators(): List<DependencyInjectorGenerator> =
private fun generatorForLazyLocalClassifierAnalyzer() =
generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyLocalClassifierAnalyzer") {
parameter<Project>()
parameter<GlobalContext>(useAsContext = true)
parameter<ModuleContext>(useAsContext = true)
parameter<BindingTrace>()
parameter<ModuleDescriptor>(name = "module", useAsContext = true)
parameter<AdditionalCheckerProvider>(useAsContext = true)
parameter<DynamicTypesSettings>()
parameter<LocalClassDescriptorHolder>()
@@ -100,15 +98,13 @@ private fun generatorForLazyLocalClassifierAnalyzer() =
private fun generatorForLazyBodyResolve() =
generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyBodyResolve") {
parameter<Project>()
parameter<GlobalContext>(useAsContext = true)
parameter<KotlinCodeAnalyzer>(name = "analyzer", useAsContext = true)
parameter<ModuleContext>(useAsContext = true)
parameter<KotlinCodeAnalyzer>(name = "analyzer")
parameter<FileScopeProvider>()
parameter<BindingTrace>()
parameter<AdditionalCheckerProvider>(useAsContext = true)
parameter<DynamicTypesSettings>()
field<ModuleDescriptor>(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true)
publicField<LazyTopDownAnalyzerForTopLevel>()
}
@@ -222,10 +218,8 @@ private fun generatorForTests() =
private fun generatorForBodyResolve() =
generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForBodyResolve") {
parameter<Project>()
parameter<GlobalContext>(useAsContext = true)
parameter<ModuleContext>(useAsContext = true)
parameter<BindingTrace>()
parameter<ModuleDescriptor>(useAsContext = true)
parameter<AdditionalCheckerProvider>(useAsContext = true)
parameter<StatementFilter>()
@@ -234,9 +228,7 @@ private fun generatorForBodyResolve() =
private fun generatorForLazyResolve() =
generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyResolve") {
parameter<Project>()
parameter<GlobalContext>(useAsContext = true)
parameter<ModuleDescriptorImpl>(useAsContext = true)
parameter<ModuleContext>(useAsContext = true)
parameter<DeclarationProviderFactory>()
parameter<BindingTrace>()
parameter<AdditionalCheckerProvider>(useAsContext = true)
@@ -249,10 +241,8 @@ private fun generatorForLazyResolve() =
}
private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
parameter<Project>()
parameter<GlobalContext>(useAsContext = true)
publicParameter<ModuleContext>(useAsContext = true)
parameter<BindingTrace>()
publicParameter<ModuleDescriptorImpl>(name = "module", useAsContext = true)
parameter<DeclarationProviderFactory>()
publicField<ResolveSession>()
idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt
+5 -4
View File
@@ -21,10 +21,12 @@ import com.google.common.base.Functions
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.analyzer.computeTypeInContext
import org.jetbrains.kotlin.cfg.JetFlowInformationProvider
import org.jetbrains.kotlin.context.GlobalContextImpl
import org.jetbrains.kotlin.context.SimpleGlobalContext
import org.jetbrains.kotlin.context.withModule
import org.jetbrains.kotlin.context.withProject
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.descriptors.annotations.Annotations
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.di.InjectorForBodyResolve
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
@@ -38,7 +40,6 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor
import org.jetbrains.kotlin.resolve.scopes.ChainedScope
import org.jetbrains.kotlin.resolve.scopes.JetScope
import org.jetbrains.kotlin.storage.LockBasedStorageManager
import org.jetbrains.kotlin.types.TypeUtils
import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
@@ -372,8 +373,8 @@ public abstract class ElementResolver protected(
private fun createBodyResolver(resolveSession: ResolveSession, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter): BodyResolver {
val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
val bodyResolve = InjectorForBodyResolve(
file.getProject(), globalContext,
trace, resolveSession.getModuleDescriptor(), getAdditionalCheckerProvider(file), statementFilter
globalContext.withProject(file.getProject()).withModule(resolveSession.getModuleDescriptor() as ModuleDescriptorImpl),
trace, getAdditionalCheckerProvider(file), statementFilter
)
return bodyResolve.getBodyResolver()
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt
+7 -9
View File
@@ -16,13 +16,11 @@
package org.jetbrains.kotlin.idea.caches.resolve
import com.intellij.openapi.project.Project
import com.intellij.openapi.roots.OrderRootType
import com.intellij.util.PathUtil
import org.jetbrains.kotlin.analyzer.*
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.di.InjectorForLazyResolve
import org.jetbrains.kotlin.idea.framework.JsHeaderLibraryDetectionUtil
import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
@@ -44,29 +42,29 @@ public object JsAnalyzerFacade : AnalyzerFacade<JsResolverForModule, PlatformAna
override fun <M : ModuleInfo> createResolverForModule(
moduleInfo: M,
project: Project,
globalContext: GlobalContext,
moduleDescriptor: ModuleDescriptorImpl,
moduleContext: ModuleContext,
moduleContent: ModuleContent,
platformParameters: PlatformAnalysisParameters,
resolverForProject: ResolverForProject<M, JsResolverForModule>
): JsResolverForModule {
val (syntheticFiles, moduleContentScope) = moduleContent
val project = moduleContext.project
val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
project, globalContext.storageManager, syntheticFiles, moduleContentScope
project, moduleContext.storageManager, syntheticFiles, moduleContentScope
)
val injector = InjectorForLazyResolve(project, globalContext, moduleDescriptor, declarationProviderFactory, BindingTraceContext(),
val injector = InjectorForLazyResolve(moduleContext, declarationProviderFactory, BindingTraceContext(),
KotlinJsCheckerProvider, DynamicTypesAllowed())
val resolveSession = injector.getResolveSession()!!
var packageFragmentProvider = resolveSession.getPackageFragmentProvider()
val moduleDescriptor = moduleContext.module
if (moduleInfo is LibraryInfo) {
val files = moduleInfo.library.getFiles(OrderRootType.CLASSES)
if (!JsHeaderLibraryDetectionUtil.isJsHeaderLibraryWithSources(files.toList())) {
val providers = moduleInfo.library.getFiles(OrderRootType.CLASSES)
.flatMap { KotlinJavascriptMetadataUtils.loadMetadata(PathUtil.getLocalPath(it)!!) }
.map { KotlinJavascriptSerializationUtil.createPackageFragmentProvider(moduleDescriptor, it.body, globalContext.storageManager) }
.map { KotlinJavascriptSerializationUtil.createPackageFragmentProvider(moduleDescriptor, it.body, moduleContext.storageManager) }
.filterNotNull()
if (providers.isNotEmpty()) {
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt
+7 -2
View File
@@ -30,6 +30,9 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult
import org.jetbrains.kotlin.analyzer.analyzeInContext
import org.jetbrains.kotlin.asJava.LightClassUtil
import org.jetbrains.kotlin.context.SimpleGlobalContext
import org.jetbrains.kotlin.context.withModule
import org.jetbrains.kotlin.context.withProject
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.di.InjectorForLazyBodyResolve
import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
@@ -223,10 +226,12 @@ private object KotlinResolveDataProvider {
val trace = DelegatingBindingTrace(resolveSession.getBindingContext(), "Trace for resolution of " + analyzableElement)
val targetPlatform = TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile())
val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
val moduleContext = globalContext.withProject(project).withModule(resolveSession.getModuleDescriptor() as ModuleDescriptorImpl)
val lazyTopDownAnalyzer = InjectorForLazyBodyResolve(
project,
SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker()),
moduleContext,
resolveSession,
resolveSession.getScopeProvider(),
trace,
targetPlatform.getAdditionalCheckerProvider(),
targetPlatform.getDynamicTypesSettings()
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt
+14 -16
View File
@@ -16,24 +16,21 @@
package org.jetbrains.kotlin.idea.caches.resolve
import com.intellij.openapi.project.Project
import com.intellij.openapi.roots.ModuleRootManager
import com.intellij.openapi.module.ModuleManager
import org.jetbrains.kotlin.utils.keysToMap
import com.intellij.openapi.roots.LibraryOrderEntry
import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
import com.intellij.openapi.project.Project
import com.intellij.openapi.roots.JdkOrderEntry
import org.jetbrains.kotlin.analyzer.AnalyzerFacade
import org.jetbrains.kotlin.analyzer.ResolverForModule
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.storage.ExceptionTracker
import org.jetbrains.kotlin.load.java.structure.JavaClass
import org.jetbrains.kotlin.analyzer.ResolverForProject
import org.jetbrains.kotlin.analyzer.ModuleContent
import org.jetbrains.kotlin.analyzer.EmptyResolverForProject
import com.intellij.openapi.roots.LibraryOrderEntry
import com.intellij.openapi.roots.ModuleRootManager
import org.jetbrains.kotlin.analyzer.*
import org.jetbrains.kotlin.context.GlobalContextImpl
import org.jetbrains.kotlin.context.withProject
import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
import org.jetbrains.kotlin.load.java.structure.JavaClass
import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
import org.jetbrains.kotlin.psi.JetFile
import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
import org.jetbrains.kotlin.storage.ExceptionTracker
import org.jetbrains.kotlin.utils.keysToMap
fun createModuleResolverProvider(
project: Project,
@@ -64,7 +61,8 @@ fun createModuleResolverProvider(
}
val resolverForProject = analyzerFacade.setupResolverForProject(
globalContext, project, modulesToCreateResolversFor, modulesContent, jvmPlatformParameters, delegateProvider.resolverForProject
globalContext.withProject(project), modulesToCreateResolversFor, modulesContent,
jvmPlatformParameters, delegateProvider.resolverForProject
)
return resolverForProject
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java
+7 -9
View File
@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.asJava.LightClassUtil;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.codegen.binding.PsiCodegenPredictor;
import org.jetbrains.kotlin.context.ContextPackage;
import org.jetbrains.kotlin.context.GlobalContextImpl;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.descriptors.CallableDescriptor;
import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -233,24 +233,22 @@ public class JetSourceNavigationHelper {
@NotNull Collection<JetNamedDeclaration> candidates,
@NotNull Project project
) {
GlobalContextImpl globalContext = ContextPackage.GlobalContext();
FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(
globalContext.getStorageManager(),
getContainingFiles(candidates)
);
ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"),
TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS,
PlatformToKotlinClassMap.EMPTY);
ModuleContext moduleContext = ContextPackage.ModuleContext(moduleDescriptor, project);
FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(
moduleContext.getStorageManager(),
getContainingFiles(candidates)
);
moduleDescriptor.addDependencyOnModule(moduleDescriptor);
moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
moduleDescriptor.seal();
ResolveSession resolveSession = new InjectorForLazyResolve(
project,
globalContext,
moduleDescriptor,
moduleContext,
providerFactory,
new BindingTraceContext(),
AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java
+5 -5
View File
@@ -38,7 +38,7 @@ import org.jetbrains.annotations.TestOnly;
import org.jetbrains.kotlin.asJava.LightClassUtil;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.context.ContextPackage;
import org.jetbrains.kotlin.context.GlobalContextImpl;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.di.InjectorForLazyResolve;
@@ -95,19 +95,19 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
final Runnable initializeRunnable = new Runnable() {
@Override
public void run() {
GlobalContextImpl globalContext = ContextPackage.GlobalContext();
ModuleDescriptorImpl module = new ModuleDescriptorImpl(
Name.special("<built-ins resolver module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY
);
module.addDependencyOnModule(module);
module.seal();
ModuleContext moduleContext = ContextPackage.ModuleContext(module, myProject);
FileBasedDeclarationProviderFactory declarationFactory =
new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), jetBuiltInsFiles);
new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), jetBuiltInsFiles);
InjectorForLazyResolve injectorForLazyResolve =
new InjectorForLazyResolve(myProject, globalContext, module, declarationFactory, new BindingTraceContext(),
new InjectorForLazyResolve(moduleContext, declarationFactory, new BindingTraceContext(),
AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
new DynamicTypesSettings());
idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt
+2 -2
View File
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.decompiler.textBuilder
import com.intellij.openapi.project.Project
import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -65,7 +65,7 @@ class ProjectBasedResolverForDecompiler(project: Project) : ResolverForDecompile
module.addDependencyOnModule(module)
module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
module.seal()
TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(project, GlobalContext(), listOf(), BindingTraceContext(), module, null, null).moduleDescriptor
TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(ModuleContext(module, project), listOf(), BindingTraceContext(), null, null).moduleDescriptor
}
override fun resolveTopLevelClass(classId: ClassId): ClassDescriptor? {
js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java
+23 -25
View File
@@ -16,13 +16,13 @@
package org.jetbrains.kotlin.di;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import com.intellij.openapi.project.Project;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
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;
@@ -76,13 +76,13 @@ import javax.annotation.PreDestroy;
@SuppressWarnings("all")
public class InjectorForTopDownAnalyzerForJs {
private final ModuleContext moduleContext;
private final KotlinBuiltIns kotlinBuiltIns;
private final ModuleDescriptorImpl moduleDescriptor;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final Project project;
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final BindingTrace bindingTrace;
private final ModuleDescriptorImpl module;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final DeclarationProviderFactory declarationProviderFactory;
private final ResolveSession resolveSession;
private final ScopeProvider scopeProvider;
@@ -131,21 +131,19 @@ public class InjectorForTopDownAnalyzerForJs {
private final VarianceChecker varianceChecker;
public InjectorForTopDownAnalyzerForJs(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull ModuleContext moduleContext,
@NotNull BindingTrace bindingTrace,
@NotNull ModuleDescriptorImpl module,
@NotNull DeclarationProviderFactory declarationProviderFactory
) {
this.project = project;
this.globalContext = globalContext;
this.storageManager = globalContext.getStorageManager();
this.moduleContext = moduleContext;
this.kotlinBuiltIns = moduleContext.getBuiltIns();
this.moduleDescriptor = moduleContext.getModule();
this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
this.project = moduleContext.getProject();
this.storageManager = moduleContext.getStorageManager();
this.bindingTrace = bindingTrace;
this.module = module;
this.kotlinBuiltIns = module.getBuiltIns();
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
this.declarationProviderFactory = declarationProviderFactory;
this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
this.resolveSession = new ResolveSession(project, getModuleContext(), moduleDescriptor, declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
this.kotlinJsCheckerProvider = KotlinJsCheckerProvider.INSTANCE$;
@@ -163,20 +161,20 @@ public class InjectorForTopDownAnalyzerForJs {
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
this.typeLazinessToken = new TypeLazinessToken();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesAllowed);
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesAllowed);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.fakeCallResolver = new FakeCallResolver(project, callResolver);
this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
this.reflectionTypes = new ReflectionTypes(getModule());
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.valueParameterResolver = new ValueParameterResolver(kotlinJsCheckerProvider, expressionTypingServices);
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
this.jetImportsFactory = new JetImportsFactory();
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
this.lazyDeclarationResolver = new LazyDeclarationResolver(getModuleContext(), bindingTrace);
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
this.scriptBodyResolver = new ScriptBodyResolver();
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
@@ -236,7 +234,7 @@ public class InjectorForTopDownAnalyzerForJs {
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setGlobalContext(moduleContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
@@ -282,7 +280,7 @@ public class InjectorForTopDownAnalyzerForJs {
lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
lazyTopDownAnalyzer.setModuleDescriptor(module);
lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
@@ -322,8 +320,8 @@ public class InjectorForTopDownAnalyzerForJs {
public void destroy() {
}
public ModuleDescriptorImpl getModule() {
return this.module;
public ModuleContext getModuleContext() {
return this.moduleContext;
}
public ResolveSession getResolveSession() {
js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java
+4 -8
View File
@@ -17,11 +17,10 @@
package org.jetbrains.kotlin.js.analyze;
import com.google.common.collect.ImmutableList;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.context.ContextPackage;
import org.jetbrains.kotlin.context.GlobalContextImpl;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJs;
@@ -75,15 +74,12 @@ public final class TopDownAnalyzerFacadeForJS {
@NotNull ModuleDescriptorImpl module,
@NotNull Config config
) {
Project project = config.getProject();
GlobalContextImpl globalContext = ContextPackage.GlobalContext();
ModuleContext context = ContextPackage.ModuleContext(module, config.getProject());
Collection<JetFile> allFiles = Config.withJsLibAdded(files, config);
InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
project, globalContext, trace, module,
new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), allFiles));
context, trace, new FileBasedDeclarationProviderFactory(context.getStorageManager(), allFiles)
);
try {
injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files,
Collections.<PackageFragmentProvider>emptyList());