From cfdb1f4ec348a69e0adba6041e25262d85bc41ea Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Tue, 19 May 2015 16:34:31 +0300 Subject: [PATCH] Refactor creation of ModuleDescriptor Add storageManager to ModuleDescriptorImpl (to be used later) Extract ModuleParameters to hold default imports and platform class map Introduce MutableModuleContext to simplify module creation code --- .../kotlin/codegen/JvmRuntimeTypes.java | 12 ++-- .../compiler/KotlinToJVMBytecodeCompiler.java | 7 +-- .../kotlin/cli/jvm/repl/ReplInterpreter.java | 15 ++--- .../kotlin/resolve/jvm/JvmAnalyzerFacade.kt | 6 +- .../jvm/TopDownAnalyzerFacadeForJVM.java | 39 +++++++----- .../kotlin/analyzer/AnalyzerFacade.kt | 9 +-- .../org/jetbrains/kotlin/context/context.kt | 38 ++++++++++++ .../checkers/AbstractJetDiagnosticsTest.java | 60 +++++++++++-------- ...bstractJetDiagnosticsTestWithJsStdLib.java | 28 ++++----- ...csTestWithJsStdLibAndBackendCompilation.kt | 16 ++--- .../jvm/compiler/AbstractLoadJavaTest.java | 9 ++- .../AbstractDescriptorRendererTest.kt | 12 ++-- .../kotlin/resolve/lazy/JvmResolveUtil.java | 15 ++--- .../resolve/lazy/LazyResolveTestUtil.java | 9 ++- .../AbstractLocalClassProtoTest.kt | 6 +- .../jetbrains/kotlin/test/JetTestUtils.java | 8 ++- .../InjectorForRuntimeDescriptorLoader.java | 15 ++--- .../load/kotlin/reflect/RuntimeModuleData.kt | 9 ++- .../kotlin/builtins/KotlinBuiltIns.java | 7 +-- .../kotlin/descriptors/ModuleDescriptor.kt | 28 ++++++--- .../descriptors/impl/ModuleDescriptorImpl.kt | 10 ++-- .../jetbrains/kotlin/types/ErrorUtils.java | 7 +-- .../generators/injectors/GenerateInjectors.kt | 4 +- .../idea/caches/resolve/JsAnalyzerFacade.kt | 7 +-- .../navigation/JetSourceNavigationHelper.java | 28 +++++---- .../textBuilder/DeserializerForDecompiler.kt | 10 ++-- .../references/BuiltInsReferenceResolver.java | 42 +++++++------ .../DecompiledTextConsistencyTest.kt | 10 ++-- .../analyze/TopDownAnalyzerFacadeForJS.java | 55 ++++++++++------- .../jetbrains/kotlin/js/config/Config.java | 17 ++++-- 30 files changed, 304 insertions(+), 234 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java index 3009141e8e6..267190edfed 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java @@ -20,11 +20,14 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.builtins.ReflectionTypes; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.Annotations; +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor; import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor; import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; +import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM; +import org.jetbrains.kotlin.storage.LockBasedStorageManager; import org.jetbrains.kotlin.types.*; import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils; @@ -34,7 +37,6 @@ import java.util.Collection; import java.util.List; import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getBuiltIns; -import static org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM.createJavaModule; public class JvmRuntimeTypes { private final ReflectionTypes reflectionTypes; @@ -46,10 +48,10 @@ public class JvmRuntimeTypes { public JvmRuntimeTypes(@NotNull ReflectionTypes reflectionTypes) { this.reflectionTypes = reflectionTypes; - PackageFragmentDescriptor kotlinJvmInternal = new MutablePackageFragmentDescriptor( - createJavaModule(""), - new FqName("kotlin.jvm.internal") - ); + ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special(""), + LockBasedStorageManager.NO_LOCKS, + TopDownAnalyzerFacadeForJVM.JVM_MODULE_PARAMETERS); + PackageFragmentDescriptor kotlinJvmInternal = new MutablePackageFragmentDescriptor(module, new FqName("kotlin.jvm.internal")); this.functionImpl = createClass(kotlinJvmInternal, "FunctionImpl", "out R"); this.memberFunctionImpl = createClass(kotlinJvmInternal, "MemberFunctionImpl", "in T", "out R"); diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index b7996401fa5..f871ed2f644 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -40,8 +40,7 @@ import org.jetbrains.kotlin.codegen.*; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.Progress; import org.jetbrains.kotlin.config.CompilerConfiguration; -import org.jetbrains.kotlin.context.ContextPackage; -import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; +import org.jetbrains.kotlin.context.ModuleContext; import org.jetbrains.kotlin.idea.MainFunctionDetector; import org.jetbrains.kotlin.load.kotlin.PackageClassUtils; import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCache; @@ -317,10 +316,10 @@ public class KotlinToJVMBytecodeCompiler { @Override public AnalysisResult invoke() { BindingTrace sharedTrace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(); - ModuleDescriptorImpl analyzeModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule(); + ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.getProject()); return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext( - ContextPackage.ModuleContext(analyzeModule, environment.getProject()), + moduleContext, environment.getSourceFiles(), sharedTrace, environment.getConfiguration().get(JVMConfigurationKeys.MODULE_IDS), diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java index a91d4219124..6bbe9d3e8b4 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java @@ -43,8 +43,7 @@ import org.jetbrains.kotlin.codegen.CompilationErrorHandler; 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.ModuleContext; +import org.jetbrains.kotlin.context.MutableModuleContext; import org.jetbrains.kotlin.descriptors.ScriptDescriptor; import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; @@ -108,9 +107,8 @@ public class ReplInterpreter { Project project = environment.getProject(); this.psiFileFactory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project); this.trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(); - this.module = TopDownAnalyzerFacadeForJVM.createJavaModule(""); - - ModuleContext context = ContextPackage.ModuleContext(module, project); + MutableModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project); + this.module = moduleContext.getModule(); scriptDeclarationFactory = new ScriptMutableDeclarationProviderFactory(); @@ -123,7 +121,7 @@ public class ReplInterpreter { }; InjectorForReplWithJava injector = new InjectorForReplWithJava( - context, + moduleContext, trace, scriptDeclarationFactory, ProjectScope.getAllScope(project), @@ -134,15 +132,12 @@ public class ReplInterpreter { this.topDownAnalyzer = injector.getLazyTopDownAnalyzerForTopLevel(); this.resolveSession = injector.getResolveSession(); - module.initialize(new CompositePackageFragmentProvider( + moduleContext.initializeModuleContents(new CompositePackageFragmentProvider( Arrays.asList( injector.getResolveSession().getPackageFragmentProvider(), injector.getJavaDescriptorResolver().getPackageFragmentProvider() ) )); - module.addDependencyOnModule(module); - module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); - module.seal(); List classpath = Lists.newArrayList(); for (File file : getJvmClasspathRoots(configuration)) { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt index 6fb4ca123cf..e420da2d629 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt @@ -20,13 +20,13 @@ import com.intellij.openapi.project.Project import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.analyzer.* import org.jetbrains.kotlin.context.ModuleContext +import org.jetbrains.kotlin.descriptors.ModuleParameters import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider 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 @@ -79,8 +79,8 @@ public object JvmAnalyzerFacade : AnalyzerFacade): List { val allFiles = ArrayList(baseFiles) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java index 27f99307150..0004e1fc361 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java @@ -23,9 +23,10 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.analyzer.AnalysisResult; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.context.ModuleContext; +import org.jetbrains.kotlin.context.MutableModuleContext; import org.jetbrains.kotlin.descriptors.ClassDescriptor; +import org.jetbrains.kotlin.descriptors.ModuleParameters; import org.jetbrains.kotlin.descriptors.PackageFragmentProvider; -import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider; import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCache; @@ -33,6 +34,7 @@ import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCacheProvid import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.platform.JavaToKotlinClassMap; +import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.resolve.BindingTrace; import org.jetbrains.kotlin.resolve.DescriptorUtils; @@ -44,6 +46,8 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; +import static org.jetbrains.kotlin.context.ContextPackage.ContextForNewModule; + public enum TopDownAnalyzerFacadeForJVM { INSTANCE; @@ -66,6 +70,20 @@ public enum TopDownAnalyzerFacadeForJVM { return list; } + public static ModuleParameters JVM_MODULE_PARAMETERS = new ModuleParameters() { + @NotNull + @Override + public List getDefaultImports() { + return DEFAULT_IMPORTS; + } + + @NotNull + @Override + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return JavaToKotlinClassMap.INSTANCE; + } + }; + @NotNull public static AnalysisResult analyzeFilesWithJavaIntegrationNoIncremental( @NotNull ModuleContext moduleContext, @@ -138,18 +156,11 @@ public enum TopDownAnalyzerFacadeForJVM { } @NotNull - public static ModuleDescriptorImpl createJavaModule(@NotNull String name) { - return new ModuleDescriptorImpl(Name.special(name), - DEFAULT_IMPORTS, - JavaToKotlinClassMap.INSTANCE); - } - - @NotNull - public static ModuleDescriptorImpl createSealedJavaModule() { - ModuleDescriptorImpl module = createJavaModule(""); - module.addDependencyOnModule(module); - module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); - module.seal(); - return module; + public static MutableModuleContext createContextWithSealedModule(@NotNull Project project) { + MutableModuleContext context = ContextForNewModule( + project, Name.special(""), JVM_MODULE_PARAMETERS + ); + context.setDependencies(context.getModule(), KotlinBuiltIns.getInstance().getBuiltInsModule()); + return context; } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt index 0f3b91d0576..f6a008c5d1f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt @@ -22,11 +22,10 @@ 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.ModuleParameters 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 @@ -116,7 +115,6 @@ public trait ModuleInfo { } } -//TODO: (module refactoring) extract project context public trait AnalyzerFacade { public fun setupResolverForProject( projectContext: ProjectContext, @@ -130,7 +128,7 @@ public trait AnalyzerFacade() modules.forEach { module -> - descriptorByModule[module] = ModuleDescriptorImpl(module.name, defaultImports, platformToKotlinClassMap) + descriptorByModule[module] = ModuleDescriptorImpl(module.name, projectContext.storageManager, moduleParameters) } return ResolverForProjectImpl(descriptorByModule, delegateResolver) } @@ -193,7 +191,6 @@ public trait AnalyzerFacade ): A - public val defaultImports: List - public val platformToKotlinClassMap: PlatformToKotlinClassMap + public val moduleParameters: ModuleParameters } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/context/context.kt b/compiler/frontend/src/org/jetbrains/kotlin/context/context.kt index 0c5a5d68e3c..fbaf05fd45e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/context/context.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/context/context.kt @@ -19,6 +19,10 @@ package org.jetbrains.kotlin.context import com.intellij.openapi.project.Project import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.ModuleParameters +import org.jetbrains.kotlin.descriptors.PackageFragmentProvider +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap import org.jetbrains.kotlin.storage.ExceptionTracker import org.jetbrains.kotlin.storage.LockBasedStorageManager @@ -43,6 +47,25 @@ public trait ModuleContext : ProjectContext { get() = module.builtIns } +public trait MutableModuleContext: ModuleContext { + override val module: ModuleDescriptorImpl + + public fun setDependencies(vararg dependencies: ModuleDescriptorImpl) { + setDependencies(dependencies.toList()) + } + + public fun setDependencies(dependencies: List) { + for (dependency in dependencies) { + module.addDependencyOnModule(dependency) + } + module.seal() + } + + public fun initializeModuleContents(packageFragmentProvider: PackageFragmentProvider) { + module.initialize(packageFragmentProvider) + } +} + public open class SimpleGlobalContext( override val storageManager: StorageManager, override val exceptionTracker: ExceptionTracker @@ -65,6 +88,11 @@ public class ModuleContextImpl( projectContext: ProjectContext ) : ModuleContext, ProjectContext by projectContext +public class MutableModuleContextImpl( + override val module: ModuleDescriptorImpl, + projectContext: ProjectContext +) : MutableModuleContext, ProjectContext by projectContext + public fun GlobalContext(): GlobalContextImpl { val tracker = ExceptionTracker() return GlobalContextImpl(LockBasedStorageManager.createWithExceptionHandling(tracker), tracker) @@ -77,6 +105,16 @@ public fun ModuleContext(module: ModuleDescriptor, project: Project): ModuleCont public fun GlobalContext.withProject(project: Project): ProjectContext = ProjectContextImpl(project, this) public fun ProjectContext.withModule(module: ModuleDescriptor): ModuleContext = ModuleContextImpl(module, this) +public fun ContextForNewModule( + project: Project, + moduleName: Name, + parameters: ModuleParameters +): MutableModuleContext { + val projectContext = ProjectContext(project) + val module = ModuleDescriptorImpl(moduleName, projectContext.storageManager, parameters) + return MutableModuleContextImpl(module, projectContext) +} + 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") diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java index fbac8806c23..e98f4ea1f2b 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java @@ -51,6 +51,7 @@ import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM; import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil; import org.jetbrains.kotlin.storage.ExceptionTracker; import org.jetbrains.kotlin.storage.LockBasedStorageManager; +import org.jetbrains.kotlin.storage.StorageManager; import org.jetbrains.kotlin.test.InTextDirectivesUtils; import org.jetbrains.kotlin.test.JetTestUtils; import org.jetbrains.kotlin.test.util.DescriptorValidator; @@ -88,10 +89,18 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { } ); - Map modules = createModules(groupedByModule); - Map moduleBindings = new HashMap(); - LazyOperationsLog lazyOperationsLog = new LazyOperationsLog(HASH_SANITIZER); + ExceptionTracker tracker = new ExceptionTracker(); + GlobalContext context = new SimpleGlobalContext( + new LoggingStorageManager( + LockBasedStorageManager.createWithExceptionHandling(tracker), + lazyOperationsLog.getAddRecordFunction() + ), + tracker + ); + + Map modules = createModules(groupedByModule, context.getStorageManager()); + Map moduleBindings = new HashMap(); for (Map.Entry> entry : groupedByModule.entrySet()) { TestModule testModule = entry.getKey(); @@ -104,15 +113,9 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { moduleBindings.put(testModule, moduleTrace.getBindingContext()); - ExceptionTracker tracker = new ExceptionTracker(); - GlobalContext context = new SimpleGlobalContext( - new LoggingStorageManager( - LockBasedStorageManager.createWithExceptionHandling(tracker), - lazyOperationsLog.getAddRecordFunction() - ), - tracker - ); - analyzeModuleContents(context, jetFiles, module, moduleTrace); + + ModuleContext moduleContext = withModule(withProject(context, getProject()), module); + analyzeModuleContents(moduleContext, jetFiles, moduleTrace); checkAllResolvedCallsAreCompleted(jetFiles, moduleTrace.getBindingContext()); } @@ -222,13 +225,10 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { } protected void analyzeModuleContents( - GlobalContext context, - List jetFiles, - ModuleDescriptorImpl module, - BindingTrace moduleTrace + @NotNull ModuleContext moduleContext, + @NotNull List jetFiles, + @NotNull 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( @@ -308,14 +308,17 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { return RECURSIVE.filterRecursion(stepIntoFilter).withValidationStrategy(DescriptorValidator.ValidationVisitor.errorTypesAllowed()); } - private Map createModules(Map> groupedByModule) { + private Map createModules( + @NotNull Map> groupedByModule, + @NotNull StorageManager storageManager + ) { Map modules = new HashMap(); for (TestModule testModule : groupedByModule.keySet()) { ModuleDescriptorImpl module = testModule == null ? - createSealedModule() : - createModule("<" + testModule.getName() + ">"); + createSealedModule(storageManager) : + createModule("<" + testModule.getName() + ">", storageManager); modules.put(testModule, module); } @@ -336,13 +339,20 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { return modules; } - protected ModuleDescriptorImpl createModule(String moduleName) { - return TopDownAnalyzerFacadeForJVM.createJavaModule(moduleName); + @NotNull + protected ModuleDescriptorImpl createModule(@NotNull String moduleName, @NotNull StorageManager storageManager) { + return new ModuleDescriptorImpl(Name.special(moduleName), + storageManager, + TopDownAnalyzerFacadeForJVM.JVM_MODULE_PARAMETERS); } @NotNull - protected ModuleDescriptorImpl createSealedModule() { - return TopDownAnalyzerFacadeForJVM.createSealedJavaModule(); + protected ModuleDescriptorImpl createSealedModule(@NotNull StorageManager storageManager) { + ModuleDescriptorImpl moduleDescriptor = createModule("", storageManager); + moduleDescriptor.addDependencyOnModule(moduleDescriptor); + moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + moduleDescriptor.seal(); + return moduleDescriptor; } private static void checkAllResolvedCallsAreCompleted(@NotNull List jetFiles, @NotNull BindingContext bindingContext) { diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java index b7302614f2c..41bf80b5679 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java @@ -22,14 +22,15 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.config.CompilerConfiguration; -import org.jetbrains.kotlin.context.GlobalContext; +import org.jetbrains.kotlin.context.ModuleContext; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS; import org.jetbrains.kotlin.js.config.Config; -import org.jetbrains.kotlin.js.config.EcmaVersion; import org.jetbrains.kotlin.js.config.LibrarySourcesConfig; +import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.resolve.BindingTrace; +import org.jetbrains.kotlin.storage.StorageManager; import java.util.List; import java.util.Map; @@ -57,12 +58,11 @@ public abstract class AbstractJetDiagnosticsTestWithJsStdLib extends AbstractJet @Override protected void analyzeModuleContents( - GlobalContext context, - List jetFiles, - ModuleDescriptorImpl module, - BindingTrace moduleTrace + @NotNull ModuleContext moduleContext, + @NotNull List jetFiles, + @NotNull BindingTrace moduleTrace ) { - TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, module, config); + TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, moduleContext, config); } @Override @@ -70,25 +70,25 @@ public abstract class AbstractJetDiagnosticsTestWithJsStdLib extends AbstractJet return true; } + @NotNull @Override - protected ModuleDescriptorImpl createModule(String moduleName) { - return TopDownAnalyzerFacadeForJS.createJsModule(moduleName); + protected ModuleDescriptorImpl createModule(@NotNull String moduleName, @NotNull StorageManager storageManager) { + return new ModuleDescriptorImpl(Name.special(moduleName), storageManager, TopDownAnalyzerFacadeForJS.JS_MODULE_PARAMETERS); } @NotNull @Override - protected ModuleDescriptorImpl createSealedModule() { - //It's JVM specific thing, so for JS we just create and setup module. - - ModuleDescriptorImpl module = createModule(""); + protected ModuleDescriptorImpl createSealedModule(@NotNull StorageManager storageManager) { + ModuleDescriptorImpl module = createModule("", storageManager); module.addDependencyOnModule(module); - module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); for(ModuleDescriptorImpl moduleDescriptor : config.getModuleDescriptors()) { module.addDependencyOnModule(moduleDescriptor); } + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + module.seal(); return module; diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation.kt b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation.kt index 74e75aaed86..8f6759e49c2 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation.kt +++ b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation.kt @@ -16,27 +16,21 @@ package org.jetbrains.kotlin.checkers -import org.jetbrains.kotlin.context.GlobalContext -import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.context.ModuleContext +import org.jetbrains.kotlin.diagnostics.DiagnosticUtils.hasError import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS -import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult import org.jetbrains.kotlin.js.facade.K2JSTranslator import org.jetbrains.kotlin.js.facade.MainCallParameters -import org.jetbrains.kotlin.js.facade.exceptions.TranslationException import org.jetbrains.kotlin.psi.JetFile import org.jetbrains.kotlin.resolve.BindingTrace -import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics - -import org.jetbrains.kotlin.diagnostics.DiagnosticUtils.hasError public abstract class AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation : AbstractJetDiagnosticsTestWithJsStdLib() { override fun analyzeModuleContents( - context: GlobalContext, - jetFiles: List, - module: ModuleDescriptorImpl, + moduleContext: ModuleContext, + jetFiles: MutableList, moduleTrace: BindingTrace ) { - val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, module, getConfig()) + val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, moduleContext, getConfig()) val diagnostics = analysisResult.bindingTrace.getBindingContext().getDiagnostics() if (!hasError(diagnostics)) { diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java index 22eaf7be5b5..94756fff497 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java @@ -25,11 +25,10 @@ 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.config.CompilerConfiguration; -import org.jetbrains.kotlin.context.ContextPackage; +import org.jetbrains.kotlin.context.ModuleContext; import org.jetbrains.kotlin.descriptors.ClassDescriptor; import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; import org.jetbrains.kotlin.descriptors.PackageViewDescriptor; -import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.BindingTrace; @@ -148,16 +147,16 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(); - ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule(); + ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.getProject()); TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental( - ContextPackage.ModuleContext(module, environment.getProject()), + moduleContext, environment.getSourceFiles(), trace, TopDownAnalysisMode.TopLevelDeclarations ); - PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME); + PackageViewDescriptor packageView = moduleContext.getModule().getPackage(TEST_PACKAGE_FQNAME); assert packageView != null : "Test package not found"; checkJavaPackage(expectedFile, packageView, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT); diff --git a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt index 66fbf5bfdf6..b2ed1e535e8 100644 --- a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt @@ -21,7 +21,6 @@ import com.intellij.openapi.util.io.FileUtil import com.intellij.testFramework.UsefulTestCase import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport 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 @@ -48,16 +47,15 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment val fileText = FileUtil.loadFile(File(path), true) val psiFile = JetPsiFactory(getProject()).createFile(fileText) - val lazyModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule() - val moduleContext = ModuleContext(lazyModule, getProject()) + val context = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(getProject()) val resolveSession = InjectorForLazyResolve( - moduleContext, - FileBasedDeclarationProviderFactory(moduleContext.storageManager, listOf(psiFile)), + context, + FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)), CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), KotlinJvmCheckerProvider, DynamicTypesSettings()).getResolveSession() - lazyModule.initialize(resolveSession.getPackageFragmentProvider()) + context.initializeModuleContents(resolveSession.getPackageFragmentProvider()) val descriptors = ArrayList() @@ -65,7 +63,7 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment override fun visitJetFile(file: JetFile) { val fqName = file.getPackageFqName() if (!fqName.isRoot()) { - val packageDescriptor = lazyModule.getPackage(fqName) + val packageDescriptor = context.module.getPackage(fqName) descriptors.add(packageDescriptor) } file.acceptChildren(this) diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java index 2eda3f9e41b..d61f88c46a6 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java +++ b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java @@ -19,10 +19,8 @@ package org.jetbrains.kotlin.resolve.lazy; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.analyzer.AnalysisResult; -import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport; -import org.jetbrains.kotlin.context.ContextPackage; -import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; +import org.jetbrains.kotlin.context.ModuleContext; import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.resolve.AnalyzingUtils; import org.jetbrains.kotlin.resolve.BindingTrace; @@ -45,8 +43,7 @@ public class JvmResolveUtil { @NotNull public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file) { - return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file) - ); + return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file)); } @NotNull @@ -70,14 +67,10 @@ public class JvmResolveUtil { @NotNull Project project, @NotNull Collection files ) { - ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createJavaModule(""); - module.addDependencyOnModule(module); - module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); - module.seal(); + ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project); BindingTrace trace = new CliLightClassGenerationSupport.CliBindingTrace(); - return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext( - ContextPackage.ModuleContext(module, project), files, trace, null, null); + return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(moduleContext, files, trace, null, null); } } diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java index 24f215fa431..29221fbcdb4 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java @@ -21,9 +21,8 @@ import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; -import org.jetbrains.kotlin.context.ContextPackage; +import org.jetbrains.kotlin.context.ModuleContext; import org.jetbrains.kotlin.descriptors.ModuleDescriptor; -import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.name.SpecialNames; import org.jetbrains.kotlin.psi.JetFile; @@ -53,13 +52,13 @@ public class LazyResolveTestUtil { @NotNull public static ModuleDescriptor resolve(@NotNull Project project, @NotNull BindingTrace trace, @NotNull List sourceFiles) { - ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule(); + ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project); TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental( - ContextPackage.ModuleContext(module, project), sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations + moduleContext, sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations ); - return module; + return moduleContext.getModule(); } @NotNull diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt index 787aec64bda..56d394e19a7 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt @@ -21,7 +21,6 @@ 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.ModuleContext import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil import org.jetbrains.kotlin.load.java.JvmAnnotationNames @@ -53,15 +52,14 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() { JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir), EnvironmentConfigFiles.JVM_CONFIG_FILES ) - val module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule() - val moduleContext = ModuleContext(module, environment.project) + val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.project) val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, emptyList()) val injector = InjectorForTopDownAnalyzerForJvm( moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), providerFactory, GlobalSearchScope.allScope(environment.project) ) - module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider) + moduleContext.initializeModuleContents(injector.getJavaDescriptorResolver().packageFragmentProvider) val components = injector.getDeserializationComponentsForJava().components diff --git a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java b/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java index a697c880a78..d233e20e8a9 100644 --- a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java @@ -52,6 +52,7 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys; import org.jetbrains.kotlin.config.CompilerConfiguration; import org.jetbrains.kotlin.config.ContentRoot; import org.jetbrains.kotlin.config.KotlinSourceRoot; +import org.jetbrains.kotlin.descriptors.ModuleParameters; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.diagnostics.Diagnostic; import org.jetbrains.kotlin.diagnostics.Errors; @@ -60,15 +61,14 @@ import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages; import org.jetbrains.kotlin.idea.JetLanguage; import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.name.Name; -import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.psi.JetExpression; import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.BindingTrace; -import org.jetbrains.kotlin.resolve.ImportPath; import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics; import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil; import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil; +import org.jetbrains.kotlin.storage.LockBasedStorageManager; import org.jetbrains.kotlin.test.util.UtilPackage; import org.jetbrains.kotlin.types.JetType; import org.jetbrains.kotlin.types.expressions.JetTypeInfo; @@ -911,7 +911,9 @@ public class JetTestUtils { @NotNull public static ModuleDescriptorImpl createEmptyModule(@NotNull String name) { - return new ModuleDescriptorImpl(Name.special(name), Collections.emptyList(), PlatformToKotlinClassMap.EMPTY); + return new ModuleDescriptorImpl( + Name.special(name), LockBasedStorageManager.NO_LOCKS, ModuleParameters.Empty.INSTANCE$ + ); } @NotNull diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java b/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java index f15e28bcb6d..685a1cc6a5f 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.di; import org.jetbrains.kotlin.descriptors.ModuleDescriptor; +import org.jetbrains.kotlin.storage.StorageManager; import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver; import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava; import org.jetbrains.kotlin.load.java.components.ExternalSignatureResolver; @@ -28,7 +29,6 @@ import org.jetbrains.kotlin.load.java.components.SamConversionResolver; import org.jetbrains.kotlin.load.java.components.RuntimeErrorReporter; import org.jetbrains.kotlin.load.java.components.RuntimeSourceElementFactory; import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver; -import org.jetbrains.kotlin.storage.LockBasedStorageManager; import org.jetbrains.kotlin.load.java.reflect.ReflectJavaClassFinder; import org.jetbrains.kotlin.load.kotlin.reflect.ReflectKotlinClassFinder; import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider; @@ -46,6 +46,7 @@ public class InjectorForRuntimeDescriptorLoader { private final ClassLoader classLoader; private final ModuleDescriptor moduleDescriptor; + private final StorageManager storageManager; private final JavaDescriptorResolver javaDescriptorResolver; private final DeserializationComponentsForJava deserializationComponentsForJava; private final ExternalSignatureResolver externalSignatureResolver; @@ -57,7 +58,6 @@ public class InjectorForRuntimeDescriptorLoader { private final RuntimeErrorReporter runtimeErrorReporter; private final RuntimeSourceElementFactory runtimeSourceElementFactory; private final SingleModuleClassResolver singleModuleClassResolver; - private final LockBasedStorageManager lockBasedStorageManager; private final ReflectJavaClassFinder reflectJavaClassFinder; private final ReflectKotlinClassFinder reflectKotlinClassFinder; private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; @@ -69,11 +69,12 @@ public class InjectorForRuntimeDescriptorLoader { public InjectorForRuntimeDescriptorLoader( @NotNull ClassLoader classLoader, - @NotNull ModuleDescriptor moduleDescriptor + @NotNull ModuleDescriptor moduleDescriptor, + @NotNull StorageManager storageManager ) { this.classLoader = classLoader; this.moduleDescriptor = moduleDescriptor; - this.lockBasedStorageManager = new LockBasedStorageManager(); + this.storageManager = storageManager; this.reflectJavaClassFinder = new ReflectJavaClassFinder(classLoader); this.reflectKotlinClassFinder = new ReflectKotlinClassFinder(classLoader); this.runtimeErrorReporter = RuntimeErrorReporter.INSTANCE$; @@ -86,13 +87,13 @@ public class InjectorForRuntimeDescriptorLoader { this.samConversionResolver = SamConversionResolver.EMPTY; this.runtimeSourceElementFactory = RuntimeSourceElementFactory.INSTANCE$; this.singleModuleClassResolver = new SingleModuleClassResolver(); - this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, reflectJavaClassFinder, reflectKotlinClassFinder, deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, runtimeErrorReporter, methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, runtimeSourceElementFactory, singleModuleClassResolver); + this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, reflectJavaClassFinder, reflectKotlinClassFinder, deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, runtimeErrorReporter, methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, runtimeSourceElementFactory, singleModuleClassResolver); this.reflectionTypes = new ReflectionTypes(getModuleDescriptor()); this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor(), reflectionTypes); this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModuleDescriptor()); this.javaClassDataFinder = new JavaClassDataFinder(reflectKotlinClassFinder, deserializedDescriptorResolver); - this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModuleDescriptor(), lockBasedStorageManager, reflectKotlinClassFinder, runtimeErrorReporter); - this.deserializationComponentsForJava = new DeserializationComponentsForJava(lockBasedStorageManager, getModuleDescriptor(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider); + this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModuleDescriptor(), storageManager, reflectKotlinClassFinder, runtimeErrorReporter); + this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModuleDescriptor(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider); singleModuleClassResolver.setResolver(javaDescriptorResolver); diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt index eaca97c31bb..d80a656d1fa 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt @@ -17,12 +17,14 @@ package org.jetbrains.kotlin.load.kotlin.reflect import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.descriptors.ModuleParameters import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.di.InjectorForRuntimeDescriptorLoader import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.platform.JavaToKotlinClassMap import org.jetbrains.kotlin.serialization.deserialization.LocalClassResolver +import org.jetbrains.kotlin.storage.LockBasedStorageManager public class RuntimeModuleData private(private val injector: InjectorForRuntimeDescriptorLoader) { public val module: ModuleDescriptor get() = injector.getModuleDescriptor() @@ -31,10 +33,13 @@ public class RuntimeModuleData private(private val injector: InjectorForRuntimeD companion object { public fun create(classLoader: ClassLoader): RuntimeModuleData { - val module = ModuleDescriptorImpl(Name.special(""), listOf(), JavaToKotlinClassMap.INSTANCE) + val storageManager = LockBasedStorageManager() + val module = ModuleDescriptorImpl(Name.special(""), storageManager, + ModuleParameters(listOf(), JavaToKotlinClassMap.INSTANCE)) module.addDependencyOnModule(module) module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()) - val injector = InjectorForRuntimeDescriptorLoader(classLoader, module) + module.seal() + val injector = InjectorForRuntimeDescriptorLoader(classLoader, module, storageManager) module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider) return RuntimeModuleData(injector) } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java index a84626f7d69..ec88eb0e18a 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java @@ -28,9 +28,7 @@ import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.FqNameUnsafe; import org.jetbrains.kotlin.name.Name; -import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.resolve.DescriptorUtils; -import org.jetbrains.kotlin.resolve.ImportPath; import org.jetbrains.kotlin.resolve.scopes.JetScope; import org.jetbrains.kotlin.serialization.deserialization.FlexibleTypeCapabilitiesDeserializer; import org.jetbrains.kotlin.storage.LockBasedStorageManager; @@ -109,12 +107,13 @@ public class KotlinBuiltIns { public static final FqNames FQ_NAMES = new FqNames(); private KotlinBuiltIns() { + LockBasedStorageManager storageManager = new LockBasedStorageManager(); builtInsModule = new ModuleDescriptorImpl( - Name.special(""), Collections.emptyList(), PlatformToKotlinClassMap.EMPTY + Name.special(""), storageManager, ModuleParameters.Empty.INSTANCE$ ); PackageFragmentProvider packageFragmentProvider = BuiltinsPackage.createBuiltInPackageFragmentProvider( - new LockBasedStorageManager(), builtInsModule, Collections.singleton(BUILT_INS_PACKAGE_FQ_NAME), + storageManager, builtInsModule, Collections.singleton(BUILT_INS_PACKAGE_FQ_NAME), FlexibleTypeCapabilitiesDeserializer.ThrowException.INSTANCE$, new Function1() { @Override public InputStream invoke(String path) { diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ModuleDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ModuleDescriptor.kt index ff8cc2f8d4f..0fde09f5947 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ModuleDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ModuleDescriptor.kt @@ -16,14 +16,14 @@ package org.jetbrains.kotlin.descriptors +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.descriptors.impl.PackageViewDescriptorImpl +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap import org.jetbrains.kotlin.resolve.ImportPath -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.types.TypeSubstitutor -import org.jetbrains.kotlin.descriptors.impl.PackageViewDescriptorImpl -import org.jetbrains.kotlin.builtins.KotlinBuiltIns -public trait ModuleDescriptor : DeclarationDescriptor { +public trait ModuleDescriptor : DeclarationDescriptor, ModuleParameters { override fun getContainingDeclaration(): DeclarationDescriptor? = null public fun getPackageFragmentProvider(): PackageFragmentProvider @@ -33,10 +33,6 @@ public trait ModuleDescriptor : DeclarationDescriptor { return if (!fragments.isEmpty()) PackageViewDescriptorImpl(this, fqName, fragments) else null } - public val defaultImports: List - - public val platformToKotlinClassMap: PlatformToKotlinClassMap - public val builtIns: KotlinBuiltIns public fun isFriend(other: ModuleDescriptor): Boolean @@ -49,3 +45,19 @@ public trait ModuleDescriptor : DeclarationDescriptor { return visitor.visitModuleDeclaration(this, data) } } + +trait ModuleParameters { + public val defaultImports: List + public val platformToKotlinClassMap: PlatformToKotlinClassMap + + object Empty: ModuleParameters { + override val defaultImports: List = emptyList() + override val platformToKotlinClassMap: PlatformToKotlinClassMap = PlatformToKotlinClassMap.EMPTY + } +} + +public fun ModuleParameters(defaultImports: List, platformToKotlinClassMap: PlatformToKotlinClassMap): ModuleParameters = + object : ModuleParameters { + override val defaultImports: List = defaultImports + override val platformToKotlinClassMap: PlatformToKotlinClassMap = platformToKotlinClassMap + } \ No newline at end of file diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt index 78f4fa74243..867b3f5fc03 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt @@ -18,20 +18,20 @@ package org.jetbrains.kotlin.descriptors.impl import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.ModuleParameters import org.jetbrains.kotlin.descriptors.PackageFragmentProvider import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap -import org.jetbrains.kotlin.resolve.ImportPath +import org.jetbrains.kotlin.storage.StorageManager import java.util.ArrayList import java.util.LinkedHashSet import kotlin.properties.Delegates public class ModuleDescriptorImpl( moduleName: Name, - override val defaultImports: List, - override val platformToKotlinClassMap: PlatformToKotlinClassMap -) : DeclarationDescriptorImpl(Annotations.EMPTY, moduleName), ModuleDescriptor { + private val storageManager: StorageManager, + private val moduleParameters: ModuleParameters +) : DeclarationDescriptorImpl(Annotations.EMPTY, moduleName), ModuleDescriptor, ModuleParameters by moduleParameters { init { if (!moduleName.isSpecial()) { throw IllegalArgumentException("Module name must be special: $moduleName") diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java index 7c47febe51e..e627df4508a 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java @@ -24,10 +24,9 @@ import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.Annotations; import org.jetbrains.kotlin.descriptors.impl.*; import org.jetbrains.kotlin.name.Name; -import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; -import org.jetbrains.kotlin.resolve.ImportPath; import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter; import org.jetbrains.kotlin.resolve.scopes.JetScope; +import org.jetbrains.kotlin.storage.LockBasedStorageManager; import org.jetbrains.kotlin.types.error.ErrorSimpleFunctionDescriptorImpl; import org.jetbrains.kotlin.utils.Printer; @@ -44,8 +43,8 @@ public class ErrorUtils { static { ERROR_MODULE = new ModuleDescriptorImpl( Name.special(""), - Collections.emptyList(), - PlatformToKotlinClassMap.EMPTY + LockBasedStorageManager.NO_LOCKS, + ModuleParameters.Empty.INSTANCE$ ); } diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index d20cc1ce929..774ab945525 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -44,7 +44,7 @@ import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct import org.jetbrains.kotlin.resolve.lazy.* import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory -import org.jetbrains.kotlin.storage.LockBasedStorageManager +import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.types.DynamicTypesAllowed import org.jetbrains.kotlin.types.DynamicTypesSettings import org.jetbrains.kotlin.types.expressions.* @@ -127,6 +127,7 @@ private fun generatorForRuntimeDescriptorLoader() = generator("core/descriptors.runtime/src", DI_DEFAULT_PACKAGE, "InjectorForRuntimeDescriptorLoader") { parameter() publicParameter() + parameter() publicField() publicField() @@ -142,7 +143,6 @@ private fun generatorForRuntimeDescriptorLoader() = field() field() - field() field() field() } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt index fccb640f940..e53c3a6a623 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt @@ -20,13 +20,13 @@ import com.intellij.openapi.roots.OrderRootType import com.intellij.util.PathUtil import org.jetbrains.kotlin.analyzer.* import org.jetbrains.kotlin.context.ModuleContext +import org.jetbrains.kotlin.descriptors.ModuleParameters 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 import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider -import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap import org.jetbrains.kotlin.resolve.BindingTraceContext import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService @@ -77,7 +77,6 @@ public object JsAnalyzerFacade : AnalyzerFacade"), - TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS, - PlatformToKotlinClassMap.EMPTY); - ModuleContext moduleContext = ContextPackage.ModuleContext(moduleDescriptor, project); + MutableModuleContext newModuleContext = ContextPackage.ContextForNewModule( + project, Name.special(""), + ModuleParameters( + TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS, + PlatformToKotlinClassMap.EMPTY + ) + ); + + newModuleContext.setDependencies(newModuleContext.getModule(), KotlinBuiltIns.getInstance().getBuiltInsModule()); + FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory( - moduleContext.getStorageManager(), + newModuleContext.getStorageManager(), getContainingFiles(candidates) ); - moduleDescriptor.addDependencyOnModule(moduleDescriptor); - moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); - moduleDescriptor.seal(); - ResolveSession resolveSession = new InjectorForLazyResolve( - moduleContext, + newModuleContext, providerFactory, new BindingTraceContext(), AdditionalCheckerProvider.DefaultProvider.INSTANCE$, new DynamicTypesSettings()).getResolveSession(); - moduleDescriptor.initialize(resolveSession.getPackageFragmentProvider()); + newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider()); return resolveSession; } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompiler.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompiler.kt index 897ba47520a..75da2d3d810 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompiler.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompiler.kt @@ -20,6 +20,7 @@ import com.intellij.openapi.diagnostic.Logger import com.intellij.openapi.vfs.VirtualFile import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.ModuleParameters import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor import org.jetbrains.kotlin.descriptors.PackageFragmentProvider import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl @@ -31,7 +32,6 @@ import org.jetbrains.kotlin.load.kotlin.PackageClassUtils import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPackageMemberScope import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil @@ -46,10 +46,10 @@ public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDec public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val directoryPackageFqName: FqName) : ResolverForDecompiler { - private val moduleDescriptor = - ModuleDescriptorImpl(Name.special(""), listOf(), PlatformToKotlinClassMap.EMPTY) + private val storageManager = LockBasedStorageManager.NO_LOCKS + private val moduleDescriptor = createDummyModule("module for building decompiled sources") - private fun createDummyModule(name: String) = ModuleDescriptorImpl(Name.special("<$name>"), listOf(), PlatformToKotlinClassMap.EMPTY) + private fun createDummyModule(name: String) = ModuleDescriptorImpl(Name.special("<$name>"), storageManager, ModuleParameters.Empty) override fun resolveTopLevelClass(classId: ClassId) = deserializationComponents.deserializeClass(classId) @@ -74,8 +74,6 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di private val classFinder = DirectoryBasedClassFinder(packageDirectory, directoryPackageFqName) private val classDataFinder = DirectoryBasedDataFinder(classFinder, LOG) - private val storageManager = LockBasedStorageManager.NO_LOCKS - private val annotationAndConstantLoader = BinaryClassAnnotationAndConstantLoaderImpl(moduleDescriptor, storageManager, classFinder, LoggingErrorReporter(LOG)) diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java index 5cbf21ee574..23f051ae092 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java @@ -38,15 +38,18 @@ 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.ModuleContext; +import org.jetbrains.kotlin.context.MutableModuleContext; +import org.jetbrains.kotlin.context.ProjectContext; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.di.InjectorForLazyResolve; import org.jetbrains.kotlin.name.Name; -import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.renderer.DescriptorRenderer; -import org.jetbrains.kotlin.resolve.*; +import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; +import org.jetbrains.kotlin.resolve.BindingTraceContext; +import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; +import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; import org.jetbrains.kotlin.resolve.scopes.JetScope; import org.jetbrains.kotlin.types.DynamicTypesSettings; @@ -55,7 +58,10 @@ import org.jetbrains.kotlin.utils.UtilsPackage; import java.io.File; import java.net.MalformedURLException; import java.net.URL; -import java.util.*; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getClassId; import static org.jetbrains.kotlin.serialization.deserialization.DeserializationPackage.findClassAcrossModuleDependencies; @@ -95,23 +101,22 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent { final Runnable initializeRunnable = new Runnable() { @Override public void run() { - ModuleDescriptorImpl module = new ModuleDescriptorImpl( - Name.special(""), Collections.emptyList(), PlatformToKotlinClassMap.EMPTY - ); - module.addDependencyOnModule(module); - module.seal(); - - ModuleContext moduleContext = ContextPackage.ModuleContext(module, myProject); + MutableModuleContext newModuleContext = ContextPackage + .ContextForNewModule(myProject, Name.special(""), ModuleParameters.Empty.INSTANCE$); + newModuleContext.setDependencies(newModuleContext.getModule()); FileBasedDeclarationProviderFactory declarationFactory = - new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), jetBuiltInsFiles); + new FileBasedDeclarationProviderFactory(newModuleContext.getStorageManager(), jetBuiltInsFiles); InjectorForLazyResolve injectorForLazyResolve = - new InjectorForLazyResolve(moduleContext, declarationFactory, new BindingTraceContext(), - AdditionalCheckerProvider.DefaultProvider.INSTANCE$, - new DynamicTypesSettings()); + new InjectorForLazyResolve( + newModuleContext, + declarationFactory, new BindingTraceContext(), + AdditionalCheckerProvider.DefaultProvider.INSTANCE$, + new DynamicTypesSettings() + ); - module.initialize(injectorForLazyResolve.getResolveSession().getPackageFragmentProvider()); + newModuleContext.initializeModuleContents(injectorForLazyResolve.getResolveSession().getPackageFragmentProvider()); if (!ApplicationManager.getApplication().isUnitTestMode()) { // Use lazy initialization in tests @@ -119,9 +124,9 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent { } List fragments = - module.getPackageFragmentProvider().getPackageFragments(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME); + newModuleContext.getModule().getPackageFragmentProvider().getPackageFragments(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME); - moduleDescriptor = module; + BuiltInsReferenceResolver.this.moduleDescriptor = newModuleContext.getModule(); builtinsPackageFragment = KotlinPackage.single(fragments); builtInsSources = Sets.newHashSet(jetBuiltInsFiles); } @@ -138,7 +143,6 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent { } }); } - } @NotNull diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt index 153f9c3aff3..e0d63be589d 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt @@ -19,7 +19,6 @@ 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.ModuleContext import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptor @@ -61,11 +60,10 @@ public class DecompiledTextConsistencyTest : JetLightCodeInsightFixtureTestCase( class ProjectBasedResolverForDecompiler(project: Project) : ResolverForDecompiler { val module: ModuleDescriptor = run { - val module = TopDownAnalyzerFacadeForJVM.createJavaModule("") - module.addDependencyOnModule(module) - module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()) - module.seal() - TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(ModuleContext(module, project), listOf(), BindingTraceContext(), null, null).moduleDescriptor + TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext( + TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project), + listOf(), BindingTraceContext(), null, null + ).moduleDescriptor } override fun resolveTopLevelClass(classId: ClassId): ClassDescriptor? { diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java index 96484eb22c2..0932699ff31 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java @@ -21,6 +21,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.context.ContextPackage; import org.jetbrains.kotlin.context.ModuleContext; +import org.jetbrains.kotlin.context.MutableModuleContext; +import org.jetbrains.kotlin.descriptors.ModuleParameters; import org.jetbrains.kotlin.descriptors.PackageFragmentProvider; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJs; @@ -32,6 +34,7 @@ import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.resolve.*; import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; +import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; @@ -43,10 +46,23 @@ public final class TopDownAnalyzerFacadeForJS { new ImportPath("kotlin.js.*") ); + public static ModuleParameters JS_MODULE_PARAMETERS = new ModuleParameters() { + @NotNull + @Override + public List getDefaultImports() { + return DEFAULT_IMPORTS; + } + + @NotNull + @Override + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return PlatformToKotlinClassMap.EMPTY; + } + }; + private TopDownAnalyzerFacadeForJS() { } - //TODO: refactor @NotNull public static JsAnalysisResult analyzeFiles( @NotNull Collection files, @@ -54,36 +70,38 @@ public final class TopDownAnalyzerFacadeForJS { ) { BindingTrace trace = new BindingTraceContext(); - ModuleDescriptorImpl module = createJsModule("<" + config.getModuleId() + ">"); - module.addDependencyOnModule(module); - module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + MutableModuleContext newModuleContext = ContextPackage.ContextForNewModule( + config.getProject(), Name.special("<" + config.getModuleId() + ">"), JS_MODULE_PARAMETERS + ); + newModuleContext.setDependencies(computeDependencies(newModuleContext.getModule(), config)); + return analyzeFilesWithGivenTrace(files, trace, newModuleContext, config); + } - for(ModuleDescriptorImpl moduleDescriptor : config.getModuleDescriptors()) { - module.addDependencyOnModule(moduleDescriptor); - } - - module.seal(); - - return analyzeFilesWithGivenTrace(files, trace, module, config); + @NotNull + private static List computeDependencies(ModuleDescriptorImpl module, @NotNull Config config) { + List allDependencies = new ArrayList(); + allDependencies.add(module); + allDependencies.addAll(config.getModuleDescriptors()); + allDependencies.add(KotlinBuiltIns.getInstance().getBuiltInsModule()); + return allDependencies; } @NotNull public static JsAnalysisResult analyzeFilesWithGivenTrace( @NotNull Collection files, @NotNull BindingTrace trace, - @NotNull ModuleDescriptorImpl module, + @NotNull ModuleContext moduleContext, @NotNull Config config ) { - ModuleContext context = ContextPackage.ModuleContext(module, config.getProject()); Collection allFiles = Config.withJsLibAdded(files, config); InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( - context, trace, new FileBasedDeclarationProviderFactory(context.getStorageManager(), allFiles) + moduleContext, trace, new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles) ); try { injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, - Collections.emptyList()); - return JsAnalysisResult.success(trace, module); + Collections.emptyList()); + return JsAnalysisResult.success(trace, moduleContext.getModule()); } finally { injector.destroy(); @@ -96,9 +114,4 @@ public final class TopDownAnalyzerFacadeForJS { AnalyzingUtils.checkForSyntacticErrors(file); } } - - @NotNull - public static ModuleDescriptorImpl createJsModule(@NotNull String name) { - return new ModuleDescriptorImpl(Name.special(name), DEFAULT_IMPORTS, PlatformToKotlinClassMap.EMPTY); - } } diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java b/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java index 80f56881807..b27f020d047 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.descriptors.PackageFragmentProvider; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS; +import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil; import org.jetbrains.kotlin.storage.LockBasedStorageManager; @@ -40,10 +41,11 @@ import java.util.List; */ public abstract class Config { private final boolean inlineEnabled; - @NotNull private final Project project; @NotNull + private final LockBasedStorageManager storageManager = new LockBasedStorageManager(); + @NotNull private final List sourceFilesFromLibraries = new SmartList(); @NotNull private final EcmaVersion target; @@ -122,7 +124,6 @@ public abstract class Config { } for (ModuleDescriptorImpl module : moduleDescriptors) { setDependencies(module, moduleDescriptors); - module.seal(); } return moduleDescriptors; @@ -146,14 +147,16 @@ public abstract class Config { initialized = true; } - private static ModuleDescriptorImpl createModuleDescriptor(KotlinJavascriptMetadata metadata) { - ModuleDescriptorImpl moduleDescriptor = TopDownAnalyzerFacadeForJS.createJsModule("<" + metadata.getModuleName() + ">"); + private ModuleDescriptorImpl createModuleDescriptor(KotlinJavascriptMetadata metadata) { + ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl( + Name.special("<" + metadata.getModuleName() + ">"), storageManager, + TopDownAnalyzerFacadeForJS.JS_MODULE_PARAMETERS + ); PackageFragmentProvider provider = - KotlinJavascriptSerializationUtil.createPackageFragmentProvider(moduleDescriptor, metadata.getBody(), new LockBasedStorageManager()); + KotlinJavascriptSerializationUtil.createPackageFragmentProvider(moduleDescriptor, metadata.getBody(), storageManager); moduleDescriptor.initialize(provider != null ? provider : PackageFragmentProvider.Empty.INSTANCE$); - moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); return moduleDescriptor; } @@ -162,6 +165,8 @@ public abstract class Config { for (ModuleDescriptorImpl moduleItem : modules) { module.addDependencyOnModule(moduleItem); } + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + module.seal(); } @NotNull