diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java index f7472d81c06..24a748dfdf3 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java @@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.util.slicedmap.WritableSlice; import java.util.Collection; @@ -81,9 +82,19 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport } @NotNull - public ModuleDescriptorImpl getModule() { + public ModuleDescriptorImpl newModule() { + assert this.module == null : "module already configured: " + module; + module = AnalyzerFacadeForJVM.createJavaModule(""); + module.addDependencyOnModule(module); + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + module.seal(); + return module; + } + + @NotNull + private ModuleDescriptorImpl getModule() { if (module == null) { - module = AnalyzerFacadeForJVM.createJavaModule(""); + return newModule(); } return module; } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index 96c165f2c94..09bca946218 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -59,6 +59,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCache; import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCacheProvider; import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackage; import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.MainFunctionDetector; import org.jetbrains.jet.utils.KotlinPaths; @@ -291,8 +292,7 @@ public class KotlinToJVMBytecodeCompiler { public AnalyzeExhaust invoke() { CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()); BindingTrace sharedTrace = support.getTrace(); - ModuleDescriptorImpl sharedModule = support.getModule(); - + ModuleDescriptorImpl sharedModule = support.newModule(); IncrementalCacheProvider incrementalCacheProvider = IncrementalCacheProvider.OBJECT$.getInstance(); File incrementalCacheBaseDir = environment.getConfiguration().get(JVMConfigurationKeys.INCREMENTAL_CACHE_BASE_DIR); final IncrementalCache incrementalCache; diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java index 04a7498e172..19f4c1f386c 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java @@ -43,6 +43,7 @@ import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; +import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.PackageLikeBuilderDummy; import org.jetbrains.jet.lang.parsing.JetParserDefinition; @@ -70,12 +71,12 @@ import java.net.MalformedURLException; import java.net.URL; import java.net.URLClassLoader; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.List; import static org.jetbrains.jet.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses; import static org.jetbrains.jet.codegen.binding.CodegenBinding.registerClassNameForScript; -import static org.jetbrains.jet.lang.descriptors.DependencyKind.*; public class ReplInterpreter { @@ -109,9 +110,14 @@ public class ReplInterpreter { ); injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module); topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters); - module.addFragmentProvider(SOURCES, injector.getTopDownAnalyzer().getPackageFragmentProvider()); - module.addFragmentProvider(BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); - module.addFragmentProvider(BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider()); + module.initialize(new CompositePackageFragmentProvider( + Arrays.asList(injector.getTopDownAnalyzer().getPackageFragmentProvider(), + injector.getJavaDescriptorResolver().getPackageFragmentProvider() + ) + )); + module.addDependencyOnModule(module); + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + module.seal(); List classpath = Lists.newArrayList(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java index d837276498d..ab14c2a4d43 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java @@ -18,14 +18,25 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.DependencyKind; +import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; public class InjectorForJavaDescriptorResolverUtil { @NotNull - public static InjectorForJavaDescriptorResolver create(@NotNull Project project, @NotNull BindingTrace bindingTrace) { + public static InjectorForJavaDescriptorResolver create( + @NotNull Project project, + @NotNull BindingTrace bindingTrace, + boolean dependendOnBuitlins + ) { InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, bindingTrace); - injector.getModule().addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider()); + ModuleDescriptorImpl module = injector.getModule(); + module.initialize(injector.getJavaDescriptorResolver().getPackageFragmentProvider()); + module.addDependencyOnModule(module); + if (dependendOnBuitlins) { + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + } + module.seal(); return injector; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index bc84d9d9c2a..0731ca0438d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -32,7 +32,8 @@ import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.InjectorForLazyResolveWithJava; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; -import org.jetbrains.jet.lang.descriptors.DependencyKind; +import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider; +import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -41,7 +42,6 @@ import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCache; -import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCacheProvider; import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; @@ -49,10 +49,7 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFacto import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import java.io.File; -import java.util.Collection; -import java.util.Collections; -import java.util.List; +import java.util.*; public enum AnalyzerFacadeForJVM implements AnalyzerFacade { @@ -128,14 +125,19 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { declarationProviderFactory, trace); - resolveWithJava.getModule().addFragmentProvider( - DependencyKind.BINARIES, resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider()); + ModuleDescriptorImpl module = resolveWithJava.getModule(); + module.initialize( + new CompositePackageFragmentProvider( + Arrays.asList( + resolveWithJava.getResolveSession().getPackageFragmentProvider(), + resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider() + ))); + module.addDependencyOnModule(module); if (addBuiltIns) { - resolveWithJava.getModule().addFragmentProvider( - DependencyKind.BUILT_INS, - KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); } + module.seal(); return new JvmSetup(resolveWithJava.getResolveSession(), resolveWithJava.getJavaDescriptorResolver()); } @@ -160,12 +162,11 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module); try { - module.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider()); + List additionalProviders = new ArrayList(); if (incrementalCache != null && moduleIds != null) { for (String moduleId : moduleIds) { - module.addFragmentProvider( - DependencyKind.SOURCES, + additionalProviders.add( new IncrementalPackageFragmentProvider( files, module, globalContext.getStorageManager(), injector.getDeserializationGlobalContextForJava(), incrementalCache, moduleId, injector.getJavaDescriptorResolver() @@ -173,8 +174,9 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { ); } } + additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider()); - injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files); + injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files, additionalProviders); return AnalyzeExhaust.success(trace.getBindingContext(), module); } finally { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 93e7ac27dad..9008a973940 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -38,14 +38,10 @@ import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.storage.LockBasedStorageManager; import javax.inject.Inject; -import java.util.Collection; -import java.util.Collections; -import java.util.LinkedHashSet; -import java.util.Set; +import java.util.*; public class TopDownAnalyzer { @@ -253,16 +249,24 @@ public class TopDownAnalyzer { @NotNull public TopDownAnalysisContext analyzeFiles( @NotNull TopDownAnalysisParameters topDownAnalysisParameters, - @NotNull Collection files + @NotNull Collection files, + @NotNull PackageFragmentProvider... additionalProviders ) { - ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider); + return analyzeFiles(topDownAnalysisParameters, files, Arrays.asList(additionalProviders)); + } - // "depend on" builtins module - ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); + @NotNull + public TopDownAnalysisContext analyzeFiles( + @NotNull TopDownAnalysisParameters topDownAnalysisParameters, + @NotNull Collection files, + @NotNull List additionalProviders + ) { + CompositePackageFragmentProvider provider = + new CompositePackageFragmentProvider(KotlinPackage.plus(Arrays.asList(packageFragmentProvider), additionalProviders)); + ((ModuleDescriptorImpl) moduleDescriptor).initialize(provider); // dummy builder is used because "root" is module descriptor, // packages added to module explicitly in - TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters); doProcess(c, JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor), new PackageLikeBuilderDummy(), files); return c; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java index 0477f2ab1b5..50f4c7f6dd5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java @@ -150,9 +150,6 @@ public class ResolveSession implements KotlinCodeAnalyzer { } }; - // TODO: parameter modification - rootDescriptor.addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider); - this.scriptDescriptors = storageManager.createMemoizedFunction( new Function1() { @Override diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index 03ae167b966..0fffc64e394 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -50,7 +50,6 @@ import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.jet.config.CommonConfigurationKeys; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; -import org.jetbrains.jet.lang.descriptors.DependencyKind; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; @@ -845,7 +844,9 @@ public class JetTestUtils { public static MutablePackageFragmentDescriptor createTestPackageFragment(@NotNull Name testPackageName, @NotNull String moduleName) { ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule(moduleName); MutablePackageFragmentProvider provider = new MutablePackageFragmentProvider(module); - module.addFragmentProvider(DependencyKind.SOURCES, provider); + module.initialize(provider); + module.addDependencyOnModule(module); + module.seal(); return provider.getOrCreateFragment(FqName.topLevel(testPackageName)); } diff --git a/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java index aed56d0d84d..97a411f4648 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java @@ -26,7 +26,6 @@ import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; -import org.jetbrains.jet.lang.descriptors.DependencyKind; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.diagnostics.*; import org.jetbrains.jet.lang.psi.Call; @@ -37,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.model.MutableResolvedCall; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.io.File; import java.util.*; @@ -78,6 +78,14 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { : supportTrace; moduleBindings.put(testModule, moduleTrace.getBindingContext()); + if (module == null) { + module = support.newModule(); + } + else { + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + module.seal(); + } + // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module, // albeit with same class names AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( @@ -85,7 +93,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { jetFiles, moduleTrace, Predicates.alwaysTrue(), - module == null ? support.getModule() : module, + module, null, null ); @@ -119,9 +127,9 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { if (testModule == null) continue; ModuleDescriptorImpl module = modules.get(testModule); + module.addDependencyOnModule(module); for (TestModule dependency : testModule.getDependencies()) { - // Adding other modules as BINARIES here, because in teh reduced dependency ordering model they are equal to binaries - module.addFragmentProvider(DependencyKind.BINARIES, modules.get(dependency).getPackageFragmentProvider()); + module.addDependencyOnModule(modules.get(dependency)); } } return modules; diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index 3b996bba5b6..4dc9d12270f 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java @@ -36,7 +36,6 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClass import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.DependencyKind; import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetFile; @@ -45,6 +44,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.storage.ExceptionTracker; import org.jetbrains.jet.storage.LockBasedStorageManager; import org.jetbrains.jet.test.TestCaseWithTmpdir; @@ -158,7 +158,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { // we need the same binding trace for resolve from Java and Kotlin CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()); BindingTrace trace = support.getTrace(); - ModuleDescriptorImpl module = support.getModule(); + ModuleDescriptorImpl module = support.newModule(); TopDownAnalysisParameters parameters = TopDownAnalysisParameters.create( new LockBasedStorageManager(), @@ -173,9 +173,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { trace, module); - module.addFragmentProvider(DependencyKind.BINARIES, injectorForAnalyzer.getJavaDescriptorResolver().getPackageFragmentProvider()); - - injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(parameters, environment.getSourceFiles()); + injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles( + parameters, environment.getSourceFiles(), + injectorForAnalyzer.getJavaDescriptorResolver().getPackageFragmentProvider() + ); PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME); assert packageView != null : "Test package not found"; diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractSdkAnnotationsValidityTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractSdkAnnotationsValidityTest.java index 0262404d2bd..27ac6be2b40 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractSdkAnnotationsValidityTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractSdkAnnotationsValidityTest.java @@ -71,7 +71,7 @@ public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase BindingTrace trace = new BindingTraceContext(); InjectorForJavaDescriptorResolver injector = - InjectorForJavaDescriptorResolverUtil.create(commonEnvironment.getProject(), trace); + InjectorForJavaDescriptorResolverUtil.create(commonEnvironment.getProject(), trace, false); BindingContext bindingContext = trace.getBindingContext(); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java index 7b218e11203..9e13ecf1df6 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; +import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.codegen.GenerationUtils; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; @@ -36,8 +37,8 @@ import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; -import org.jetbrains.jet.lang.descriptors.DependencyKind; import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; +import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; @@ -92,10 +93,12 @@ public final class LoadDescriptorUtil { ); JetCoreEnvironment jetCoreEnvironment = JetCoreEnvironment.createForTests(disposable, configuration); BindingTraceContext trace = new BindingTraceContext(); - InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace); - injector.getModule().addFragmentProvider(DependencyKind.BUILT_INS, - KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); - PackageViewDescriptor packageView = injector.getModule().getPackage(TEST_PACKAGE_FQNAME); + InjectorForJavaDescriptorResolver injector = + InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace, true); + ModuleDescriptorImpl module = injector.getModule(); + + CliLightClassGenerationSupport.getInstanceForCli(jetCoreEnvironment.getProject()).setModule(module); + PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME); assert packageView != null; return Pair.create(packageView, trace.getBindingContext()); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java index 820197d0fcf..84a433b369a 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java @@ -168,8 +168,8 @@ public class ResolveDescriptorsFromExternalLibraries { } } - InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create( - jetCoreEnvironment.getProject(), new BindingTraceContext()); + InjectorForJavaDescriptorResolver injector = + InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), new BindingTraceContext(), false); ModuleDescriptor moduleDescriptor = injector.getModule(); boolean hasErrors; diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index 81a7334ad0e..fd0fbdae297 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -63,12 +63,15 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe Collection files = Lists.newArrayList(psiFile); final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule(""); - lazyModule.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); + lazyModule.addDependencyOnModule(lazyModule); + lazyModule.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + lazyModule.seal(); GlobalContextImpl globalContext = ContextPackage.GlobalContext(); final ResolveSession resolveSession = new InjectorForLazyResolve( getProject(), globalContext, lazyModule, new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), files), new BindingTraceContext()).getResolveSession(); + lazyModule.initialize(resolveSession.getPackageFragmentProvider()); final List descriptors = new ArrayList(); psiFile.accept(new JetVisitorVoid() { diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java index 6b9a79e0f11..051c75f19b6 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java @@ -22,10 +22,13 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; +import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.Collection; import java.util.Collections; @@ -73,8 +76,16 @@ public class JvmResolveUtil { ) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); + ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule(""); + module.addDependencyOnModule(module); + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + module.seal(); + CliLightClassGenerationSupport lightClassGenerationSupport = CliLightClassGenerationSupport.getInstanceForCli(project); + if (lightClassGenerationSupport != null) { + lightClassGenerationSupport.setModule(module); + } return AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, bindingTraceContext, filesToAnalyzeCompletely, - AnalyzerFacadeForJVM.createJavaModule(""), + module, null, null); } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index 2bafd1cd4a5..76bafde4cd7 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -28,7 +28,6 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.context.ContextPackage; import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; -import org.jetbrains.jet.lang.descriptors.DependencyKind; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetFile; @@ -37,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.name.SpecialNames; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.List; import java.util.Set; @@ -53,12 +53,11 @@ public class LazyResolveTestUtil { globalContext.getStorageManager(), globalContext.getExceptionTracker(), Predicates.alwaysTrue(), false, false); CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()); BindingTrace sharedTrace = support.getTrace(); - ModuleDescriptorImpl sharedModule = support.getModule(); + ModuleDescriptorImpl sharedModule = support.newModule(); InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, sharedModule); - sharedModule.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider()); - injector.getTopDownAnalyzer().analyzeFiles(params, files); + injector.getTopDownAnalyzer().analyzeFiles(params, files, injector.getJavaDescriptorResolver().getPackageFragmentProvider()); return injector.getModuleDescriptor(); } diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java b/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java index 1deea903b26..6bc0819a494 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java @@ -115,7 +115,7 @@ public class JetExpectedResolveDataUtil { @NotNull private static PsiClass findClass(String qualifiedName, Project project) { - InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext()); + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext(), false); JavaClass javaClass = injector.getJavaClassFinder().findClass(new FqName(qualifiedName)); Assert.assertNotNull("Class wasn't found: " + qualifiedName, javaClass); assertInstanceOf(javaClass, JavaClassImpl.class); diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index e5a891ae9bf..86db7894edc 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -28,11 +28,9 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.di.InjectorForTests; -import org.jetbrains.jet.lang.descriptors.DependencyKind; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.resolve.BindingTraceContext; @@ -597,10 +595,10 @@ public class JetTypeCheckerTest extends JetLiteFixture { private WritableScopeImpl addImports(JetScope scope) { WritableScopeImpl writableScope = new WritableScopeImpl( scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports"); - InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(getProject(), new BindingTraceContext()); + InjectorForJavaDescriptorResolver injector = + InjectorForJavaDescriptorResolverUtil.create(getProject(), new BindingTraceContext(), true); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); - ModuleDescriptorImpl module = (ModuleDescriptorImpl) javaDescriptorResolver.getModule(); - module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); + ModuleDescriptor module = javaDescriptorResolver.getModule(); for (ImportPath defaultImport : module.getDefaultImports()) { writableScope.importScope(module.getPackage(defaultImport.fqnPart()).getMemberScope()); } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java index 64a979bf371..ae095c52b5a 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.lang.descriptors; +import kotlin.jvm.KotlinSignature; + public interface DeclarationDescriptorVisitor { R visitPackageFragmentDescriptor(PackageFragmentDescriptor descriptor, D data); @@ -30,6 +32,7 @@ public interface DeclarationDescriptorVisitor { R visitClassDescriptor(ClassDescriptor descriptor, D data); + @KotlinSignature("fun visitModuleDeclaration(descriptor: ModuleDescriptor, data: D): R") R visitModuleDeclaration(ModuleDescriptor descriptor, D data); R visitConstructorDescriptor(ConstructorDescriptor constructorDescriptor, D data); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/DependencyKind.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/DependencyKind.java deleted file mode 100644 index 31c95160bd3..00000000000 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/DependencyKind.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright 2010-2014 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.lang.descriptors; - -public enum DependencyKind { - // Using this class is supposed to be a temporary measure before we switch to full-blown support for module dependency ordering - SOURCES, - BUILT_INS, - BINARIES -} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java deleted file mode 100644 index d0291d5889b..00000000000 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright 2010-2013 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.lang.descriptors; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.PlatformToKotlinClassMap; -import org.jetbrains.jet.lang.resolve.ImportPath; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.types.TypeSubstitutor; - -import java.util.List; - -public interface ModuleDescriptor extends DeclarationDescriptor { - @Override - @Nullable - DeclarationDescriptor getContainingDeclaration(); - - @NotNull - PackageFragmentProvider getPackageFragmentProvider(); - - @Nullable - PackageViewDescriptor getPackage(@NotNull FqName fqName); - - @NotNull - List getDefaultImports(); - - @NotNull - PlatformToKotlinClassMap getPlatformToKotlinClassMap(); - - @NotNull - @Override - ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor); - - @Override - R accept(DeclarationDescriptorVisitor visitor, D data); -} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.kt b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.kt new file mode 100644 index 00000000000..09b16b052ae --- /dev/null +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.kt @@ -0,0 +1,46 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.descriptors + +import org.jetbrains.jet.lang.PlatformToKotlinClassMap +import org.jetbrains.jet.lang.resolve.ImportPath +import org.jetbrains.jet.lang.resolve.name.FqName +import org.jetbrains.jet.lang.types.TypeSubstitutor +import org.jetbrains.jet.lang.descriptors.impl.PackageViewDescriptorImpl + +public trait ModuleDescriptor : DeclarationDescriptor { + override fun getContainingDeclaration(): DeclarationDescriptor? = null + + public fun getPackageFragmentProvider(): PackageFragmentProvider + + public fun getPackage(fqName: FqName): PackageViewDescriptor? { + val fragments = getPackageFragmentProvider().getPackageFragments(fqName) + return if (!fragments.isEmpty()) PackageViewDescriptorImpl(this, fqName, fragments) else null + } + + public val defaultImports: List + + public val platformToKotlinClassMap: PlatformToKotlinClassMap + + override fun substitute(substitutor: TypeSubstitutor): ModuleDescriptor { + return this + } + + override fun accept(visitor: DeclarationDescriptorVisitor, data: D): R { + return visitor.visitModuleDeclaration(this, data) + } +} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ModuleDescriptorImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ModuleDescriptorImpl.java deleted file mode 100644 index f0a2736db2f..00000000000 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ModuleDescriptorImpl.java +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Copyright 2010-2013 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.lang.descriptors.impl; - -import com.google.common.collect.Lists; -import com.google.common.collect.Maps; -import com.intellij.openapi.diagnostic.Logger; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.PlatformToKotlinClassMap; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import org.jetbrains.jet.lang.resolve.ImportPath; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.TypeSubstitutor; - -import java.util.ArrayList; -import java.util.List; -import java.util.Map; - -public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements ModuleDescriptor { - private static final Logger LOG = Logger.getInstance(ModuleDescriptorImpl.class); - - private final Map> prioritizedFragmentProviders = Maps.newHashMap(); - private final List fragmentProviders = Lists.newArrayList(); - private final CompositePackageFragmentProvider packageFragmentProvider = new CompositePackageFragmentProvider(fragmentProviders); - private final List defaultImports; - private final PlatformToKotlinClassMap platformToKotlinClassMap; - - public ModuleDescriptorImpl( - @NotNull Name name, - @NotNull List defaultImports, - @NotNull PlatformToKotlinClassMap platformToKotlinClassMap - ) { - super(Annotations.EMPTY, name); - if (!name.isSpecial()) { - throw new IllegalArgumentException("module name must be special: " + name); - } - this.defaultImports = defaultImports; - this.platformToKotlinClassMap = platformToKotlinClassMap; - } - - public void addFragmentProvider(@NotNull DependencyKind dependencyKind, @NotNull PackageFragmentProvider provider) { - if (fragmentProviders.contains(provider)) { - LOG.error("Trying to add already present fragment provider: " + provider); - } - List providers = prioritizedFragmentProviders.get(dependencyKind); - if (providers == null) { - providers = new ArrayList(1); - prioritizedFragmentProviders.put(dependencyKind, providers); - } - providers.add(provider); - buildProvidersList(); - } - - private void buildProvidersList() { - fragmentProviders.clear(); - for (DependencyKind dependencyKind : DependencyKind.values()) { - List providers = prioritizedFragmentProviders.get(dependencyKind); - if (providers != null) { - fragmentProviders.addAll(providers); - } - } - } - - @Override - @Nullable - public DeclarationDescriptor getContainingDeclaration() { - return null; - } - - @NotNull - @Override - public PackageFragmentProvider getPackageFragmentProvider() { - return packageFragmentProvider; - } - - @Nullable - @Override - public PackageViewDescriptor getPackage(@NotNull FqName fqName) { - List fragments = packageFragmentProvider.getPackageFragments(fqName); - return !fragments.isEmpty() ? new PackageViewDescriptorImpl(this, fqName, fragments) : null; - } - - @NotNull - @Override - public List getDefaultImports() { - return defaultImports; - } - - @NotNull - @Override - public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { - return platformToKotlinClassMap; - } - - @NotNull - @Override - public ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor) { - return this; - } - - @Override - public R accept(DeclarationDescriptorVisitor visitor, D data) { - return visitor.visitModuleDeclaration(this, data); - } -} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ModuleDescriptorImpl.kt b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ModuleDescriptorImpl.kt new file mode 100644 index 00000000000..ba32533c288 --- /dev/null +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ModuleDescriptorImpl.kt @@ -0,0 +1,87 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.descriptors.impl + +import org.jetbrains.jet.lang.resolve.name.Name +import org.jetbrains.jet.lang.PlatformToKotlinClassMap +import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider +import java.util.ArrayList +import org.jetbrains.jet.lang.resolve.ImportPath +import org.jetbrains.jet.lang.descriptors.annotations.Annotations +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor +import kotlin.properties.Delegates + +public class ModuleDescriptorImpl( + moduleName: Name, + override val defaultImports: List, + override val platformToKotlinClassMap: PlatformToKotlinClassMap +) : DeclarationDescriptorImpl(Annotations.EMPTY, moduleName), ModuleDescriptor { + { + if (!moduleName.isSpecial()) { + throw IllegalArgumentException("Module name must be special: $moduleName") + } + } + private var isSealed = false + + /* + * Sealed module cannot have its dependencies modified. Seal the module after you're done configuring it. + * Module will be sealed automatically as soon as you query its contents. + */ + public fun seal() { + if (isSealed) return + + assert(this in dependencies, "Module $id is not contained in his own dependencies, this is probably a misconfiguration") + isSealed = true + } + + private val dependencies: MutableList = ArrayList() + private var packageFragmentProviderForModuleContent: PackageFragmentProvider? = null + + private val packageFragmentProviderForWholeModuleWithDependencies by Delegates.lazy { + seal() + dependencies.forEach { + dependency -> + assert(dependency.isInitialized, "Dependency module ${dependency.id} was not initialized by the time contents of dependent module ${this.id} were queried") + } + CompositePackageFragmentProvider(dependencies.map { + it.packageFragmentProviderForModuleContent!! + }) + } + + private val isInitialized: Boolean + get() = packageFragmentProviderForModuleContent != null + + public fun addDependencyOnModule(dependency: ModuleDescriptorImpl) { + assert(!isSealed, "Can't modify dependencies of sealed module $id") + assert(dependency !in dependencies, "Trying to add dependency on module ${dependency.id} a second time for module ${this.id}, this is probably a misconfiguration") + dependencies.add(dependency) + } + + private val id: String + get() = getName().toString() + + /* + * Call initialize() to set module contents. Uninitialized module cannot be queried for its contents. + * Initialize() and seal() can be called in any order. + */ + public fun initialize(providerForModuleContent: PackageFragmentProvider) { + assert(!isInitialized, "Attempt to initialize module $id twice") + packageFragmentProviderForModuleContent = providerForModuleContent + } + + override fun getPackageFragmentProvider() = packageFragmentProviderForWholeModuleWithDependencies +} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java index 22b4cbc53a9..7ebbefb5f86 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java @@ -109,7 +109,9 @@ public class KotlinBuiltIns { Collections.emptyList(), PlatformToKotlinClassMap.EMPTY); builtinsPackageFragment = new BuiltinsPackageFragment(new LockBasedStorageManager(), builtInsModule); - builtInsModule.addFragmentProvider(DependencyKind.SOURCES, builtinsPackageFragment.getProvider()); + builtInsModule.initialize(builtinsPackageFragment.getProvider()); + builtInsModule.addDependencyOnModule(builtInsModule); + builtInsModule.seal(); primitiveTypeToNullableJetType = new EnumMap(PrimitiveType.class); primitiveTypeToArrayJetType = new EnumMap(PrimitiveType.class); diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt b/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt index 7db9b9fd950..32d67ae118e 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt @@ -58,6 +58,8 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di private val moduleDescriptor = ModuleDescriptorImpl(Name.special(""), listOf(), PlatformToKotlinClassMap.EMPTY) + private fun createDummyModule(name: String) = ModuleDescriptorImpl(Name.special("<$name>"), listOf(), PlatformToKotlinClassMap.EMPTY) + override fun resolveTopLevelClass(classFqName: FqName) = deserializationContext.classDeserializer.deserializeClass(classFqName.toClassId()) override fun resolveDeclarationsInPackage(packageFqName: FqName): Collection { @@ -140,10 +142,17 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di } { - moduleDescriptor.addFragmentProvider(DependencyKind.BUILT_INS, - KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()) - moduleDescriptor.addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider) - moduleDescriptor.addFragmentProvider(DependencyKind.BINARIES, PackageFragmentProviderForMissingDependencies(moduleDescriptor)) + moduleDescriptor.initialize(packageFragmentProvider) + moduleDescriptor.addDependencyOnModule(moduleDescriptor) + moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()) + val moduleContainingMissingDependencies = createDummyModule("module containing missing dependencies for decompiled sources") + moduleContainingMissingDependencies.addDependencyOnModule(moduleContainingMissingDependencies) + moduleContainingMissingDependencies.initialize( + PackageFragmentProviderForMissingDependencies(moduleContainingMissingDependencies) + ) + moduleDescriptor.addDependencyOnModule(moduleContainingMissingDependencies) + moduleDescriptor.seal() + moduleContainingMissingDependencies.seal() } val deserializationContext = DeserializationGlobalContext(storageManager, moduleDescriptor, classDataFinder, annotationLoader, constantLoader, packageFragmentProvider) diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index a831194caa9..76923af75cf 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -44,7 +44,6 @@ import org.jetbrains.jet.di.InjectorForLazyResolve; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DependencyKind; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingTraceContext; @@ -53,6 +52,7 @@ import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap; import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; +import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; @@ -216,24 +216,7 @@ public class JetSourceNavigationHelper { } } - Project project = decompiledDeclaration.getProject(); - GlobalContextImpl globalContext = ContextPackage.GlobalContext(); - FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory( - globalContext.getStorageManager(), - getContainingFiles(candidates)); - - ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special(""), - AnalyzerFacadeForJVM.DEFAULT_IMPORTS, - PlatformToKotlinClassMap.EMPTY); - - moduleDescriptor.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); - - KotlinCodeAnalyzer analyzer = new InjectorForLazyResolve( - project, - globalContext, - moduleDescriptor, - providerFactory, - new BindingTraceContext()).getResolveSession(); + KotlinCodeAnalyzer analyzer = createAnalyzer(candidates, decompiledDeclaration.getProject()); for (JetNamedDeclaration candidate : candidates) { //noinspection unchecked @@ -248,6 +231,36 @@ public class JetSourceNavigationHelper { return null; } + @NotNull + private static KotlinCodeAnalyzer createAnalyzer( + @NotNull Collection candidates, + @NotNull Project project + ) { + GlobalContextImpl globalContext = ContextPackage.GlobalContext(); + FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory( + globalContext.getStorageManager(), + getContainingFiles(candidates) + ); + + ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special(""), + AnalyzerFacadeForJVM.DEFAULT_IMPORTS, + PlatformToKotlinClassMap.EMPTY); + + moduleDescriptor.addDependencyOnModule(moduleDescriptor); + moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + moduleDescriptor.seal(); + + ResolveSession resolveSession = new InjectorForLazyResolve( + project, + globalContext, + moduleDescriptor, + providerFactory, + new BindingTraceContext()).getResolveSession(); + + moduleDescriptor.initialize(resolveSession.getPackageFragmentProvider()); + return resolveSession; + } + @Nullable private static JetClassOrObject getSourceForNamedClassOrObject(@NotNull JetClassOrObject decompiledClassOrObject) { FqName classFqName = decompiledClassOrObject.getFqName(); diff --git a/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java b/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java index b8c4e08583d..93558bee030 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java +++ b/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java @@ -102,6 +102,8 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent { Predicates.alwaysFalse(), true, false); ModuleDescriptorImpl module = new ModuleDescriptorImpl( Name.special(""), Collections.emptyList(), PlatformToKotlinClassMap.EMPTY); + module.addDependencyOnModule(module); + module.seal(); BindingTraceContext trace = new BindingTraceContext(); InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( myProject, topDownAnalysisParameters, trace, module); diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index bff497272c3..6e9e427b49d 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -30,7 +30,6 @@ import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.InjectorForLazyResolve; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; -import org.jetbrains.jet.lang.descriptors.DependencyKind; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetFile; @@ -79,10 +78,13 @@ public final class AnalyzerFacadeForJS { TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create( globalContext.getStorageManager(), globalContext.getExceptionTracker(), completely, false, false); + owner.addDependencyOnModule(owner); + owner.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); ModuleDescriptor libraryModule = config.getLibraryModule(); if (libraryModule != null) { - owner.addFragmentProvider(DependencyKind.BINARIES, libraryModule.getPackageFragmentProvider()); // "import" analyzed library module + owner.addDependencyOnModule((ModuleDescriptorImpl) libraryModule); // "import" analyzed library module } + owner.seal(); BindingContext libraryContext = config.getLibraryContext(); BindingTrace trace = libraryContext == null @@ -136,14 +138,18 @@ public final class AnalyzerFacadeForJS { filesScope ); ModuleDescriptorImpl module = createJsModule(""); - module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); + module.addDependencyOnModule(module); + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + module.seal(); - return new InjectorForLazyResolve( + ResolveSession session = new InjectorForLazyResolve( config.getProject(), globalContext, module, declarationProviderFactory, new BindingTraceContext()).getResolveSession(); + module.initialize(session.getPackageFragmentProvider()); + return session; } @NotNull diff --git a/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt b/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt index 1f5d1e204c5..7c0118aecec 100644 --- a/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt +++ b/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt @@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils import org.jetbrains.jet.lang.descriptors.ModuleDescriptor import org.junit.Assert import java.util.HashSet +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns // this list is not designed to contain all packages, it is need for sanity check in case test code breaks private val PACKAGES_SHOULD_BE_VALIDATED = listOf("kotlin", "kotlin.concurrent", "kotlin.jvm") map { FqName(it) } @@ -102,12 +103,15 @@ class NoInternalVisibilityInStdLibTest { configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, "../src/kotlin") configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots()) val environment = JetCoreEnvironment.createForProduction(disposable, configuration) + val module = AnalyzerFacadeForJVM.createJavaModule("") + module.addDependencyOnModule(module) + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()) AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( environment.getProject(), environment.getSourceFiles(), BindingTraceContext(), { true }, - AnalyzerFacadeForJVM.createJavaModule(""), + module, null, null ).getModuleDescriptor()