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

Refactor creation of ModuleDescriptor

Browse Source 
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
This commit is contained in:
Pavel V. Talanov
2015-05-19 16:34:31 +03:00
parent 6a3cb0eff8
commit cfdb1f4ec3
30 changed files with 304 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java
+7 -5
View File
@@ -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("<jvm functions impl>"),
new FqName("kotlin.jvm.internal")
);
ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<jvm functions impl>"),
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");
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
+3 -4
View File
@@ -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),
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java
+5 -10
View File
@@ -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("<repl>");
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<URL> classpath = Lists.newArrayList();
for (File file : getJvmClasspathRoots(configuration)) {
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt
+3 -3
View File
@@ -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<JvmResolverForModule, JvmPlatfo
return JvmResolverForModule(resolveSession, javaDescriptorResolver)
}
override val defaultImports = TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS
override val platformToKotlinClassMap = JavaToKotlinClassMap.INSTANCE
override val moduleParameters: ModuleParameters
get() = TopDownAnalyzerFacadeForJVM.JVM_MODULE_PARAMETERS
public platformStatic fun getAllFilesToAnalyze(project: Project, moduleInfo: ModuleInfo?, baseFiles: Collection<JetFile>): List<JetFile> {
val allFiles = ArrayList(baseFiles)
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java
+25 -14
View File
@@ -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<ImportPath> 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("<shared-module>");
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("<shared-module>"), JVM_MODULE_PARAMETERS
);
context.setDependencies(context.getModule(), KotlinBuiltIns.getInstance().getBuiltInsModule());
return context;
}
}
compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt
+3 -6
View File
@@ -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<A : ResolverForModule, in P : PlatformAnalysisParameters> {
public fun <M : ModuleInfo> setupResolverForProject(
projectContext: ProjectContext,
@@ -130,7 +128,7 @@ public trait AnalyzerFacade<A : ResolverForModule, in P : PlatformAnalysisParame
val descriptorByModule = HashMap<M, ModuleDescriptorImpl>()
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 : ResolverForModule, in P : PlatformAnalysisParame
platformParameters: P, resolverForProject: ResolverForProject<M, A>
): A
public val defaultImports: List<ImportPath>
public val platformToKotlinClassMap: PlatformToKotlinClassMap
public val moduleParameters: ModuleParameters
}
compiler/frontend/src/org/jetbrains/kotlin/context/context.kt
+38
View File
@@ -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<ModuleDescriptorImpl>) {
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")
compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java
+35 -25
View File
@@ -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<TestModule, ModuleDescriptorImpl> modules = createModules(groupedByModule);
Map<TestModule, BindingContext> moduleBindings = new HashMap<TestModule, BindingContext>();
LazyOperationsLog lazyOperationsLog = new LazyOperationsLog(HASH_SANITIZER);
ExceptionTracker tracker = new ExceptionTracker();
GlobalContext context = new SimpleGlobalContext(
new LoggingStorageManager(
LockBasedStorageManager.createWithExceptionHandling(tracker),
lazyOperationsLog.getAddRecordFunction()
),
tracker
);
Map<TestModule, ModuleDescriptorImpl> modules = createModules(groupedByModule, context.getStorageManager());
Map<TestModule, BindingContext> moduleBindings = new HashMap<TestModule, BindingContext>();
for (Map.Entry<TestModule, List<TestFile>> 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<JetFile> jetFiles,
ModuleDescriptorImpl module,
BindingTrace moduleTrace
@NotNull ModuleContext moduleContext,
@NotNull List<JetFile> 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<TestModule, ModuleDescriptorImpl> createModules(Map<TestModule, List<TestFile>> groupedByModule) {
private Map<TestModule, ModuleDescriptorImpl> createModules(
@NotNull Map<TestModule, List<TestFile>> groupedByModule,
@NotNull StorageManager storageManager
) {
Map<TestModule, ModuleDescriptorImpl> modules = new HashMap<TestModule, ModuleDescriptorImpl>();
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("<test-module>", storageManager);
moduleDescriptor.addDependencyOnModule(moduleDescriptor);
moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
moduleDescriptor.seal();
return moduleDescriptor;
}
private static void checkAllResolvedCallsAreCompleted(@NotNull List<JetFile> jetFiles, @NotNull BindingContext bindingContext) {
compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java
+14 -14
View File
@@ -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<JetFile> jetFiles,
ModuleDescriptorImpl module,
BindingTrace moduleTrace
@NotNull ModuleContext moduleContext,
@NotNull List<JetFile> 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("<kotlin-js-test-module>");
protected ModuleDescriptorImpl createSealedModule(@NotNull StorageManager storageManager) {
ModuleDescriptorImpl module = createModule("<kotlin-js-test-module>", 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;
compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation.kt
+5 -11
View File
@@ -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<JetFile>,
module: ModuleDescriptorImpl,
moduleContext: ModuleContext,
jetFiles: MutableList<JetFile>,
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)) {
compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java
+4 -5
View File
@@ -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);
compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt
+5 -7
View File
@@ -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<DeclarationDescriptor>()
@@ -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)
compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java
+4 -11
View File
@@ -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<JetFile> files
) {
ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createJavaModule("<module>");
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);
}
}
compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java
+4 -5
View File
@@ -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<JetFile> 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
compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt
+2 -4
View File
@@ -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
compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java
+5 -3
View File
@@ -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.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY);
return new ModuleDescriptorImpl(
Name.special(name), LockBasedStorageManager.NO_LOCKS, ModuleParameters.Empty.INSTANCE$
);
}
@NotNull
core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java
+8 -7
View File
@@ -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);
core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt
+7 -2
View File
@@ -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("<runtime module for $classLoader>"), listOf(), JavaToKotlinClassMap.INSTANCE)
val storageManager = LockBasedStorageManager()
val module = ModuleDescriptorImpl(Name.special("<runtime module for $classLoader>"), 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)
}
core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
+3 -4
View File
@@ -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("<built-ins module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY
Name.special("<built-ins module>"), 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<String, InputStream>() {
@Override
public InputStream invoke(String path) {
core/descriptors/src/org/jetbrains/kotlin/descriptors/ModuleDescriptor.kt
+20 -8
View File
@@ -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<ImportPath>
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<ImportPath>
public val platformToKotlinClassMap: PlatformToKotlinClassMap
object Empty: ModuleParameters {
override val defaultImports: List<ImportPath> = emptyList()
override val platformToKotlinClassMap: PlatformToKotlinClassMap = PlatformToKotlinClassMap.EMPTY
}
}
public fun ModuleParameters(defaultImports: List<ImportPath>, platformToKotlinClassMap: PlatformToKotlinClassMap): ModuleParameters =
object : ModuleParameters {
override val defaultImports: List<ImportPath> = defaultImports
override val platformToKotlinClassMap: PlatformToKotlinClassMap = platformToKotlinClassMap
}
core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt
+5 -5
View File
@@ -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<ImportPath>,
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")
core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java
+3 -4
View File
@@ -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("<ERROR MODULE>"),
Collections.<ImportPath>emptyList(),
PlatformToKotlinClassMap.EMPTY
LockBasedStorageManager.NO_LOCKS,
ModuleParameters.Empty.INSTANCE$
);
}
generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt
+2 -2
View File
@@ -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<ClassLoader>()
publicParameter<ModuleDescriptor>()
parameter<StorageManager>()
publicField<JavaDescriptorResolver>()
publicField<DeserializationComponentsForJava>()
@@ -142,7 +143,6 @@ private fun generatorForRuntimeDescriptorLoader() =
field<RuntimeSourceElementFactory>()
field<SingleModuleClassResolver>()
field<LockBasedStorageManager>()
field<ReflectJavaClassFinder>()
field<ReflectKotlinClassFinder>()
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt
+3 -4
View File
@@ -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<JsResolverForModule, PlatformAna
return JsResolverForModule(resolveSession)
}
override val defaultImports = TopDownAnalyzerFacadeForJS.DEFAULT_IMPORTS
override val platformToKotlinClassMap = PlatformToKotlinClassMap.EMPTY
override val moduleParameters: ModuleParameters
get() = TopDownAnalyzerFacadeForJS.JS_MODULE_PARAMETERS
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java
+15 -13
View File
@@ -40,10 +40,9 @@ 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.ModuleContext;
import org.jetbrains.kotlin.context.MutableModuleContext;
import org.jetbrains.kotlin.descriptors.CallableDescriptor;
import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.di.InjectorForLazyResolve;
import org.jetbrains.kotlin.idea.caches.resolve.JsProjectDetector;
import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex;
@@ -71,6 +70,7 @@ import java.util.Collections;
import java.util.List;
import java.util.Set;
import static org.jetbrains.kotlin.descriptors.DescriptorsPackage.ModuleParameters;
import static org.jetbrains.kotlin.idea.decompiler.navigation.MemberMatching.*;
public class JetSourceNavigationHelper {
@@ -234,27 +234,29 @@ public class JetSourceNavigationHelper {
@NotNull Project project
) {
ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"),
TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS,
PlatformToKotlinClassMap.EMPTY);
ModuleContext moduleContext = ContextPackage.ModuleContext(moduleDescriptor, project);
MutableModuleContext newModuleContext = ContextPackage.ContextForNewModule(
project, Name.special("<library module>"),
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;
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompiler.kt
+4 -6
View File
@@ -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("<module for building decompiled sources>"), 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))
idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java
+23 -19
View File
@@ -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("<built-ins resolver module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY
);
module.addDependencyOnModule(module);
module.seal();
ModuleContext moduleContext = ContextPackage.ModuleContext(module, myProject);
MutableModuleContext newModuleContext = ContextPackage
.ContextForNewModule(myProject, Name.special("<built-ins resolver module>"), 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<PackageFragmentDescriptor> 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
idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt
+4 -6
View File
@@ -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 for resolving stdlib with java top down analysis>")
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? {
js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java
+34 -21
View File
@@ -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<ImportPath> getDefaultImports() {
return DEFAULT_IMPORTS;
}
@NotNull
@Override
public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
return PlatformToKotlinClassMap.EMPTY;
}
};
private TopDownAnalyzerFacadeForJS() {
}
//TODO: refactor
@NotNull
public static JsAnalysisResult analyzeFiles(
@NotNull Collection<JetFile> 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<ModuleDescriptorImpl> computeDependencies(ModuleDescriptorImpl module, @NotNull Config config) {
List<ModuleDescriptorImpl> allDependencies = new ArrayList<ModuleDescriptorImpl>();
allDependencies.add(module);
allDependencies.addAll(config.getModuleDescriptors());
allDependencies.add(KotlinBuiltIns.getInstance().getBuiltInsModule());
return allDependencies;
}
@NotNull
public static JsAnalysisResult analyzeFilesWithGivenTrace(
@NotNull Collection<JetFile> files,
@NotNull BindingTrace trace,
@NotNull ModuleDescriptorImpl module,
@NotNull ModuleContext moduleContext,
@NotNull Config config
) {
ModuleContext context = ContextPackage.ModuleContext(module, config.getProject());
Collection<JetFile> 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.<PackageFragmentProvider>emptyList());
return JsAnalysisResult.success(trace, module);
Collections.<PackageFragmentProvider>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);
}
}
js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java
+11 -6
View File
@@ -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<JetFile> sourceFilesFromLibraries = new SmartList<JetFile>();
@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