From a72e49d8f77fba75704c3c186316b7364afd1a90 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 16 Apr 2013 19:32:50 +0400 Subject: [PATCH] Use ModuleDescriptor instead of ModuleConfiguration --- .../jet/cli/jvm/repl/ReplInterpreter.java | 4 +- .../di/InjectorForTopDownAnalyzerForJvm.java | 22 ++++---- .../resolve/java/AnalyzerFacadeForJVM.java | 11 ++-- .../jet/analyzer/AnalyzeExhaust.java | 53 +++++-------------- .../jet/analyzer/AnalyzerFacade.java | 4 +- .../analyzer/AnalyzerFacadeForEverything.java | 14 ++--- .../jet/di/InjectorForBodyResolve.java | 10 ++-- .../jet/di/InjectorForLazyResolve.java | 10 ++-- .../jetbrains/jet/di/InjectorForMacros.java | 10 ++-- .../jet/di/InjectorForTopDownAnalyzer.java | 4 +- .../di/InjectorForTopDownAnalyzerBasic.java | 15 +++--- .../lang/descriptors/ModuleDescriptor.java | 10 ++++ .../descriptors/ModuleDescriptorImpl.java | 15 ++++++ .../jet/lang/resolve/ImportsResolver.java | 28 +++++----- .../lang/resolve/NamespaceFactoryImpl.java | 16 +++--- .../resolve/QualifiedExpressionResolver.java | 9 ++-- .../jet/lang/resolve/TopDownAnalyzer.java | 5 +- .../jet/lang/resolve/TypeResolver.java | 14 ++--- .../lang/resolve/lazy/KotlinCodeAnalyzer.java | 4 -- .../lang/resolve/lazy/LazyImportScope.java | 2 +- .../jet/lang/resolve/lazy/ResolveSession.java | 29 ++++------ .../resolve/lazy/ResolveSessionUtils.java | 17 +++--- .../jet/lang/resolve/lazy/ScopeProvider.java | 2 +- .../descriptors/LazyPackageDescriptor.java | 2 +- .../jetbrains/jet/lang/types/ErrorUtils.java | 4 ++ .../expressions/ExpressionTypingUtils.java | 4 +- .../jet/lang/types/lang/KotlinBuiltIns.java | 1 - .../tests/org/jetbrains/jet/JetTestUtils.java | 10 ++++ .../jetbrains/jet/di/InjectorForTests.java | 11 ++-- .../jvm/compiler/AbstractLoadJavaTest.java | 2 +- ...ractLazyResolveDescriptorRendererTest.java | 6 +-- .../resolve/lazy/LazyResolveTestUtil.java | 8 +-- .../resolve/JetExpectedResolveDataUtil.java | 9 ++-- .../JetDefaultModalityModifiersTest.java | 2 +- .../jetbrains/jet/types/JetOverloadTest.java | 2 +- .../jet/types/JetOverridingTest.java | 2 +- .../jet/types/JetTypeCheckerTest.java | 2 +- .../jet/types/TypeSubstitutorTest.java | 3 +- .../injectors/GenerateInjectors.java | 16 +++--- .../jet/plugin/caches/JetShortNamesCache.java | 4 +- .../libraries/JetSourceNavigationHelper.java | 1 - .../macro/BaseJetVariableMacro.java | 2 +- .../project/AnalyzerFacadeWithCache.java | 7 ++- .../project/JSAnalyzerFacadeForIDEA.java | 6 +-- .../quickfix/MigrateSureInProjectFix.java | 4 +- .../JetIntroduceVariableHandler.java | 3 +- .../di/InjectorForTopDownAnalyzerForJs.java | 15 ++---- .../k2js/analyze/AnalyzerFacadeForJS.java | 18 +++---- 48 files changed, 208 insertions(+), 244 deletions(-) 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 3471b9c2da6..fc70aaf6899 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 @@ -95,7 +95,7 @@ public class ReplInterpreter { true, Collections.emptyList()); injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module); - module.setModuleConfiguration(injector.getModuleConfiguration()); + module.setModuleConfiguration(injector.getModuleDescriptor().getModuleConfiguration()); List classpath = Lists.newArrayList(); @@ -225,7 +225,7 @@ public class ReplInterpreter { earierScripts.add(Pair.create(earlierLine.getScriptDescriptor(), earlierLine.getClassName())); } - BindingContext bindingContext = AnalyzeExhaust.success(trace.getBindingContext(), injector.getModuleConfiguration()).getBindingContext(); + BindingContext bindingContext = AnalyzeExhaust.success(trace.getBindingContext(), module).getBindingContext(); GenerationState generationState = new GenerationState(psiFile.getProject(), ClassBuilderFactories.binaries(false), bindingContext, Collections.singletonList(psiFile)); generationState.getScriptCodegen().compileScript(psiFile.getScript(), scriptClassName, earierScripts, diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 30c8bff23bf..ded63dfe1d3 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -61,7 +61,6 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -78,7 +77,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final TopDownAnalysisParameters topDownAnalysisParameters; private final BindingTrace bindingTrace; private final ModuleDescriptorImpl moduleDescriptor; - private JavaBridgeConfiguration moduleConfiguration; + private JavaBridgeConfiguration javaBridgeConfiguration; private JavaDescriptorResolver javaDescriptorResolver; private PsiClassFinderImpl psiClassFinder; private NamespaceFactoryImpl namespaceFactory; @@ -130,7 +129,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.topDownAnalysisParameters = topDownAnalysisParameters; this.bindingTrace = bindingTrace; this.moduleDescriptor = moduleDescriptor; - this.moduleConfiguration = new JavaBridgeConfiguration(); + this.javaBridgeConfiguration = new JavaBridgeConfiguration(); this.javaDescriptorResolver = new JavaDescriptorResolver(); this.psiClassFinder = new PsiClassFinderImpl(); this.namespaceFactory = new NamespaceFactoryImpl(); @@ -198,7 +197,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); this.descriptorResolver.setTypeResolver(typeResolver); - this.moduleConfiguration.setJavaSemanticServices(javaSemanticServices); + this.javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices); javaDescriptorResolver.setClassResolver(javaClassResolver); javaDescriptorResolver.setConstructorResolver(javaConstructorResolver); @@ -209,7 +208,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly psiClassFinder.setProject(project); - this.namespaceFactory.setConfiguration(moduleConfiguration); this.namespaceFactory.setModuleDescriptor(moduleDescriptor); this.namespaceFactory.setTrace(bindingTrace); @@ -241,14 +239,14 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly typeResolver.setAnnotationResolver(annotationResolver); typeResolver.setDescriptorResolver(descriptorResolver); - typeResolver.setModuleConfiguration(moduleConfiguration); + typeResolver.setModuleDescriptor(moduleDescriptor); typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); - importsResolver.setConfiguration(moduleConfiguration); importsResolver.setContext(topDownAnalysisContext); importsResolver.setImportsFactory(jetImportsFactory); + importsResolver.setModuleDescriptor(moduleDescriptor); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); @@ -336,7 +334,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaPropertyResolver.setSemanticServices(javaSemanticServices); javaPropertyResolver.setTrace(bindingTrace); - moduleConfiguration.init(); + javaBridgeConfiguration.init(); psiClassFinder.initialize(); @@ -382,8 +380,12 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly return this.bindingTrace; } - public ModuleConfiguration getModuleConfiguration() { - return this.moduleConfiguration; + public ModuleDescriptorImpl getModuleDescriptor() { + return this.moduleDescriptor; + } + + public JavaBridgeConfiguration getJavaBridgeConfiguration() { + return this.javaBridgeConfiguration; } public NamespaceFactoryImpl getNamespaceFactory() { 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 c97771edd20..cdba34e1d34 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 @@ -31,6 +31,7 @@ import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.DefaultModuleConfiguration; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; @@ -72,11 +73,11 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { @NotNull Predicate filesForBodiesResolve, @NotNull BindingTrace headersTraceContext, @NotNull BodiesResolveContext bodiesResolveContext, - @NotNull ModuleConfiguration configuration + @NotNull ModuleDescriptor module ) { return AnalyzerFacadeForEverything.analyzeBodiesInFilesWithJavaIntegration( project, scriptParameters, filesForBodiesResolve, - headersTraceContext, bodiesResolveContext, configuration); + headersTraceContext, bodiesResolveContext, module); } @NotNull @@ -136,7 +137,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("")); lazyModule.setModuleConfiguration(moduleConfiguration); - return new ResolveSession(fileProject, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory, javaResolverTrace); + return new ResolveSession(fileProject, storageManager, lazyModule, declarationProviderFactory, javaResolverTrace); } public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors( @@ -209,13 +210,13 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm( project, topDownAnalysisParameters, new ObservableBindingTrace(trace), owner); - owner.setModuleConfiguration(injector.getModuleConfiguration()); + owner.setModuleConfiguration(injector.getJavaBridgeConfiguration()); try { injector.getTopDownAnalyzer().analyzeFiles(files, scriptParameters); BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ? new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) : null; - return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, injector.getModuleConfiguration()); + return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, owner); } finally { injector.destroy(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java index 3b66448d58b..f333e37bce6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java +++ b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java @@ -18,70 +18,43 @@ package org.jetbrains.jet.analyzer; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.PlatformToKotlinClassMap; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.BodiesResolveContext; -import org.jetbrains.jet.lang.resolve.ImportPath; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; - -import java.util.Collections; -import java.util.List; +import org.jetbrains.jet.lang.types.ErrorUtils; public class AnalyzeExhaust { - private static final ModuleConfiguration ERROR_CONFIGURATION = new ModuleConfiguration() { - @Override - public List getDefaultImports() { - return Collections.emptyList(); - } - @Override - public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { - } - - @NotNull - @Override - public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { - return PlatformToKotlinClassMap.EMPTY; - } - - @Override - public String toString() { - return "ERROR_CONFIGURATION"; - } - }; - - public static AnalyzeExhaust success(@NotNull BindingContext bindingContext, @NotNull ModuleConfiguration configuration) { - return new AnalyzeExhaust(bindingContext, configuration, null, null); + public static AnalyzeExhaust success(@NotNull BindingContext bindingContext, @NotNull ModuleDescriptor module) { + return new AnalyzeExhaust(bindingContext, module, null, null); } + public static AnalyzeExhaust success(@NotNull BindingContext bindingContext, @Nullable BodiesResolveContext bodiesResolveContext, - @NotNull ModuleConfiguration configuration + @NotNull ModuleDescriptor module ) { - return new AnalyzeExhaust(bindingContext, configuration, bodiesResolveContext, null); + return new AnalyzeExhaust(bindingContext, module, bodiesResolveContext, null); } public static AnalyzeExhaust error(@NotNull BindingContext bindingContext, @NotNull Throwable error) { - return new AnalyzeExhaust(bindingContext, ERROR_CONFIGURATION, null, error); + return new AnalyzeExhaust(bindingContext, ErrorUtils.getErrorModule(), null, error); } private final BindingContext bindingContext; private final Throwable error; private final BodiesResolveContext bodiesResolveContext; - private final ModuleConfiguration configuration; + private final ModuleDescriptor moduleDescriptor; private AnalyzeExhaust( @NotNull BindingContext bindingContext, - @NotNull ModuleConfiguration configuration, + @NotNull ModuleDescriptor moduleDescriptor, @Nullable BodiesResolveContext bodiesResolveContext, @Nullable Throwable error ) { this.bindingContext = bindingContext; this.error = error; this.bodiesResolveContext = bodiesResolveContext; - this.configuration = configuration; + this.moduleDescriptor = moduleDescriptor; } @Nullable @@ -110,7 +83,7 @@ public class AnalyzeExhaust { } @NotNull - public ModuleConfiguration getModuleConfiguration() { - return configuration; + public ModuleDescriptor getModuleDescriptor() { + return moduleDescriptor; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java index e289fed4863..732f6239a3b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java +++ b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java @@ -20,7 +20,7 @@ import com.google.common.base.Predicate; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -47,7 +47,7 @@ public interface AnalyzerFacade { @NotNull Predicate filesForBodiesResolve, @NotNull BindingTrace traceContext, @NotNull BodiesResolveContext bodiesResolveContext, - @NotNull ModuleConfiguration configuration + @NotNull ModuleDescriptor module ); @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java index ad1d8855a32..0a75b5b5a51 100644 --- a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java +++ b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java @@ -21,12 +21,8 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.di.InjectorForBodyResolve; -import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.BodiesResolveContext; -import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; -import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.resolve.*; import java.util.List; @@ -39,7 +35,7 @@ public class AnalyzerFacadeForEverything { Project project, List scriptParameters, Predicate filesToAnalyzeCompletely, @NotNull BindingTrace traceContext, @NotNull BodiesResolveContext bodiesResolveContext, - @NotNull ModuleConfiguration configuration) { + @NotNull ModuleDescriptor module) { TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( filesToAnalyzeCompletely, false, false, scriptParameters); @@ -49,11 +45,11 @@ public class AnalyzerFacadeForEverything { InjectorForBodyResolve injector = new InjectorForBodyResolve( project, topDownAnalysisParameters, new ObservableBindingTrace(traceContext), - bodiesResolveContext, configuration); + bodiesResolveContext, module); try { injector.getBodyResolver().resolveBodies(); - return AnalyzeExhaust.success(traceContext.getBindingContext(), configuration); + return AnalyzeExhaust.success(traceContext.getBindingContext(), module); } finally { injector.destroy(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java index 416b73a4d53..2e403ff5caa 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java @@ -21,7 +21,7 @@ import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.BodiesResolveContext; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; @@ -46,7 +46,7 @@ public class InjectorForBodyResolve { private final TopDownAnalysisParameters topDownAnalysisParameters; private final BindingTrace bindingTrace; private final BodiesResolveContext bodiesResolveContext; - private final ModuleConfiguration moduleConfiguration; + private final ModuleDescriptor moduleDescriptor; private CallResolver callResolver; private ArgumentTypeResolver argumentTypeResolver; private ExpressionTypingServices expressionTypingServices; @@ -66,14 +66,14 @@ public class InjectorForBodyResolve { @NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull BindingTrace bindingTrace, @NotNull BodiesResolveContext bodiesResolveContext, - @NotNull ModuleConfiguration moduleConfiguration + @NotNull ModuleDescriptor moduleDescriptor ) { this.bodyResolver = new BodyResolver(); this.project = project; this.topDownAnalysisParameters = topDownAnalysisParameters; this.bindingTrace = bindingTrace; this.bodiesResolveContext = bodiesResolveContext; - this.moduleConfiguration = moduleConfiguration; + this.moduleDescriptor = moduleDescriptor; this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.expressionTypingServices = new ExpressionTypingServices(); @@ -123,7 +123,7 @@ public class InjectorForBodyResolve { typeResolver.setAnnotationResolver(annotationResolver); typeResolver.setDescriptorResolver(descriptorResolver); - typeResolver.setModuleConfiguration(moduleConfiguration); + typeResolver.setModuleDescriptor(moduleDescriptor); typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 52e43b2248f..75abc36457b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -18,7 +18,7 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.resolve.TypeResolver; @@ -38,7 +38,7 @@ public class InjectorForLazyResolve { private final Project project; private final ResolveSession resolveSession; - private final ModuleConfiguration moduleConfiguration; + private final ModuleDescriptor moduleDescriptor; private DescriptorResolver descriptorResolver; private ExpressionTypingServices expressionTypingServices; private TypeResolver typeResolver; @@ -54,11 +54,11 @@ public class InjectorForLazyResolve { public InjectorForLazyResolve( @NotNull Project project, @NotNull ResolveSession resolveSession, - @NotNull ModuleConfiguration moduleConfiguration + @NotNull ModuleDescriptor moduleDescriptor ) { this.project = project; this.resolveSession = resolveSession; - this.moduleConfiguration = moduleConfiguration; + this.moduleDescriptor = moduleDescriptor; this.descriptorResolver = new DescriptorResolver(); this.expressionTypingServices = new ExpressionTypingServices(); this.typeResolver = new TypeResolver(); @@ -83,7 +83,7 @@ public class InjectorForLazyResolve { this.typeResolver.setAnnotationResolver(annotationResolver); this.typeResolver.setDescriptorResolver(descriptorResolver); - this.typeResolver.setModuleConfiguration(moduleConfiguration); + this.typeResolver.setModuleDescriptor(moduleDescriptor); this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); this.annotationResolver.setCallResolver(callResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java index f6ad222a02a..72b331eb103 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java @@ -18,7 +18,7 @@ package org.jetbrains.jet.di; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import com.intellij.openapi.project.Project; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; @@ -35,7 +35,7 @@ public class InjectorForMacros { private ExpressionTypingServices expressionTypingServices; private final Project project; - private final ModuleConfiguration moduleConfiguration; + private final ModuleDescriptor moduleDescriptor; private CallExpressionResolver callExpressionResolver; private CallResolver callResolver; private ArgumentTypeResolver argumentTypeResolver; @@ -47,11 +47,11 @@ public class InjectorForMacros { public InjectorForMacros( @NotNull Project project, - @NotNull ModuleConfiguration moduleConfiguration + @NotNull ModuleDescriptor moduleDescriptor ) { this.expressionTypingServices = new ExpressionTypingServices(); this.project = project; - this.moduleConfiguration = moduleConfiguration; + this.moduleDescriptor = moduleDescriptor; this.callExpressionResolver = new CallExpressionResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); @@ -79,7 +79,7 @@ public class InjectorForMacros { typeResolver.setAnnotationResolver(annotationResolver); typeResolver.setDescriptorResolver(descriptorResolver); - typeResolver.setModuleConfiguration(moduleConfiguration); + typeResolver.setModuleDescriptor(moduleDescriptor); typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); annotationResolver.setCallResolver(callResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzer.java index 3d223c93103..1371aee5931 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzer.java @@ -16,11 +16,11 @@ package org.jetbrains.jet.di; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; public interface InjectorForTopDownAnalyzer { - ModuleConfiguration getModuleConfiguration(); + ModuleDescriptor getModuleDescriptor(); TopDownAnalyzer getTopDownAnalyzer(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index d13c8b351b6..c79fe48893c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -26,7 +26,6 @@ import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.DeclarationResolver; @@ -61,7 +60,6 @@ public class InjectorForTopDownAnalyzerBasic { private final TopDownAnalysisParameters topDownAnalysisParameters; private final BindingTrace bindingTrace; private final ModuleDescriptorImpl moduleDescriptor; - private final ModuleConfiguration moduleConfiguration; private DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy; private NamespaceFactoryImpl namespaceFactory; private DeclarationResolver declarationResolver; @@ -85,8 +83,7 @@ public class InjectorForTopDownAnalyzerBasic { @NotNull Project project, @NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull BindingTrace bindingTrace, - @NotNull ModuleDescriptorImpl moduleDescriptor, - @NotNull ModuleConfiguration moduleConfiguration + @NotNull ModuleDescriptorImpl moduleDescriptor ) { this.topDownAnalyzer = new TopDownAnalyzer(); this.topDownAnalysisContext = new TopDownAnalysisContext(); @@ -98,7 +95,6 @@ public class InjectorForTopDownAnalyzerBasic { this.topDownAnalysisParameters = topDownAnalysisParameters; this.bindingTrace = bindingTrace; this.moduleDescriptor = moduleDescriptor; - this.moduleConfiguration = moduleConfiguration; this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl(); this.namespaceFactory = new NamespaceFactoryImpl(); this.declarationResolver = new DeclarationResolver(); @@ -150,7 +146,6 @@ public class InjectorForTopDownAnalyzerBasic { this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); this.descriptorResolver.setTypeResolver(typeResolver); - namespaceFactory.setConfiguration(moduleConfiguration); namespaceFactory.setModuleDescriptor(moduleDescriptor); namespaceFactory.setTrace(bindingTrace); @@ -182,14 +177,14 @@ public class InjectorForTopDownAnalyzerBasic { typeResolver.setAnnotationResolver(annotationResolver); typeResolver.setDescriptorResolver(descriptorResolver); - typeResolver.setModuleConfiguration(moduleConfiguration); + typeResolver.setModuleDescriptor(moduleDescriptor); typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); - importsResolver.setConfiguration(moduleConfiguration); importsResolver.setContext(topDownAnalysisContext); importsResolver.setImportsFactory(jetImportsFactory); + importsResolver.setModuleDescriptor(moduleDescriptor); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); @@ -261,4 +256,8 @@ public class InjectorForTopDownAnalyzerBasic { return this.bindingTrace; } + public ModuleDescriptorImpl getModuleDescriptor() { + return this.moduleDescriptor; + } + } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java index 5aeb4b40df6..99b1f392d7e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java @@ -19,9 +19,13 @@ package org.jetbrains.jet.lang.descriptors; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; +import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.types.TypeSubstitutor; +import java.util.List; + public interface ModuleDescriptor extends DeclarationDescriptor, NamespaceDescriptorParent { @Override @Nullable @@ -32,6 +36,12 @@ public interface ModuleDescriptor extends DeclarationDescriptor, NamespaceDescri @NotNull ModuleConfiguration getModuleConfiguration(); + @NotNull + List getDefaultImports(); + + @NotNull + PlatformToKotlinClassMap getPlatformToKotlinClassMap(); + @NotNull @Override ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java index d04399f29ea..55a1d778d7e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java @@ -19,14 +19,17 @@ package org.jetbrains.jet.lang.descriptors; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; +import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.TypeSubstitutor; import javax.inject.Inject; import java.util.Collections; +import java.util.List; public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements ClassOrNamespaceDescriptor, ModuleDescriptor { private NamespaceDescriptor rootNamepsace; @@ -63,6 +66,18 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements C return moduleConfiguration; } + @NotNull + @Override + public List getDefaultImports() { + return getModuleConfiguration().getDefaultImports(); + } + + @NotNull + @Override + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return getModuleConfiguration().getPlatformToKotlinClassMap(); + } + @Inject public ModuleDescriptorImpl setModuleConfiguration(@NotNull ModuleConfiguration moduleConfiguration) { this.moduleConfiguration = moduleConfiguration; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index 41d779823aa..99faa880ad9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -19,12 +19,8 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -42,7 +38,7 @@ public class ImportsResolver { @NotNull private TopDownAnalysisContext context; @NotNull - private ModuleConfiguration configuration; + private ModuleDescriptor moduleDescriptor; @NotNull private QualifiedExpressionResolver qualifiedExpressionResolver; @NotNull @@ -56,8 +52,8 @@ public class ImportsResolver { } @Inject - public void setConfiguration(@NotNull ModuleConfiguration configuration) { - this.configuration = configuration; + public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) { + this.moduleDescriptor = moduleDescriptor; } @Inject @@ -95,7 +91,7 @@ public class ImportsResolver { } private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List directives, JetScope rootScope) { - processImportsInFile(lookupMode, scope, directives, rootScope, configuration, trace, qualifiedExpressionResolver, importsFactory); + processImportsInFile(lookupMode, scope, directives, rootScope, moduleDescriptor, trace, qualifiedExpressionResolver, importsFactory); } public static void processImportsInFile( @@ -103,7 +99,7 @@ public class ImportsResolver { @NotNull WritableScope namespaceScope, @NotNull List importDirectives, @NotNull JetScope rootScope, - @NotNull ModuleConfiguration configuration, + @NotNull ModuleDescriptor module, @NotNull BindingTrace trace, @NotNull QualifiedExpressionResolver qualifiedExpressionResolver, @NotNull JetImportsFactory importsFactory @@ -114,13 +110,13 @@ public class ImportsResolver { namespaceScope.clearImports(); } - for (ImportPath defaultImportPath : configuration.getDefaultImports()) { + for (ImportPath defaultImportPath : module.getDefaultImports()) { TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create( trace, "transient trace to resolve default imports"); //not to trace errors of default imports JetImportDirective defaultImportDirective = importsFactory.createImportDirective(defaultImportPath); qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, namespaceScope, delayedImporter, - temporaryTrace, configuration, lookupMode); + temporaryTrace, module, lookupMode); } Map> resolvedDirectives = Maps.newHashMap(); @@ -128,7 +124,7 @@ public class ImportsResolver { for (JetImportDirective importDirective : importDirectives) { Collection descriptors = qualifiedExpressionResolver.processImportReference(importDirective, rootScope, namespaceScope, delayedImporter, - trace, configuration, lookupMode); + trace, module, lookupMode); if (!descriptors.isEmpty()) { resolvedDirectives.put(importDirective, descriptors); } @@ -136,7 +132,7 @@ public class ImportsResolver { JetExpression importedReference = importDirective.getImportedReference(); if (lookupMode != LookupMode.ONLY_CLASSES && importedReference != null) { for (DeclarationDescriptor descriptor : descriptors) { - reportPlatformClassMappedToKotlin(configuration, trace, importedReference, descriptor); + reportPlatformClassMappedToKotlin(module, trace, importedReference, descriptor); } } } @@ -150,14 +146,14 @@ public class ImportsResolver { } public static void reportPlatformClassMappedToKotlin( - @NotNull ModuleConfiguration configuration, + @NotNull ModuleDescriptor module, @NotNull BindingTrace trace, @NotNull JetElement element, @NotNull DeclarationDescriptor descriptor ) { if (!(descriptor instanceof ClassDescriptor)) return; - PlatformToKotlinClassMap platformToKotlinMap = configuration.getPlatformToKotlinClassMap(); + PlatformToKotlinClassMap platformToKotlinMap = module.getPlatformToKotlinClassMap(); Collection kotlinAnalogsForClass = platformToKotlinMap.mapPlatformClass((ClassDescriptor) descriptor); if (!kotlinAnalogsForClass.isEmpty()) { trace.report(PLATFORM_CLASS_MAPPED_TO_KOTLIN.on(element, kotlinAnalogsForClass)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java index e9439743052..d3a6382d9ef 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java @@ -20,13 +20,15 @@ import com.google.common.collect.Sets; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetNamespaceHeader; +import org.jetbrains.jet.lang.psi.JetReferenceExpression; +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; @@ -45,7 +47,6 @@ public class NamespaceFactoryImpl implements NamespaceFactory { private ModuleDescriptorImpl moduleDescriptor; private BindingTrace trace; - private ModuleConfiguration configuration; @Inject public void setModuleDescriptor(ModuleDescriptorImpl moduleDescriptor) { @@ -57,11 +58,6 @@ public class NamespaceFactoryImpl implements NamespaceFactory { this.trace = trace; } - @Inject - public void setConfiguration(ModuleConfiguration configuration) { - this.configuration = configuration; - } - @NotNull public NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull JetFile file, @NotNull JetScope outerScope, @@ -190,7 +186,7 @@ public class NamespaceFactoryImpl implements NamespaceFactory { namespaceDescriptor.initialize(scope); scope.changeLockLevel(WritableScope.LockLevel.BOTH); // - configuration.extendNamespaceScope(trace, namespaceDescriptor, scope); + moduleDescriptor.getModuleConfiguration().extendNamespaceScope(trace, namespaceDescriptor, scope); owner.addNamespace(namespaceDescriptor); if (expression != null) { trace.record(BindingContext.NAMESPACE, expression, namespaceDescriptor); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java index fa5b9e6f543..0163c60f60f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java @@ -22,7 +22,6 @@ import com.google.common.collect.Lists; import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.*; @@ -49,9 +48,9 @@ public class QualifiedExpressionResolver { @NotNull JetImportDirective importDirective, @NotNull JetScope scope, @NotNull BindingTrace trace, - @NotNull ModuleConfiguration moduleConfiguration + @NotNull ModuleDescriptor module ) { - return processImportReference(importDirective, scope, scope, Importer.DO_NOTHING, trace, moduleConfiguration, LookupMode.EVERYTHING); + return processImportReference(importDirective, scope, scope, Importer.DO_NOTHING, trace, module, LookupMode.EVERYTHING); } @NotNull @@ -61,7 +60,7 @@ public class QualifiedExpressionResolver { @NotNull JetScope scopeToCheckVisibility, @NotNull Importer importer, @NotNull BindingTrace trace, - @NotNull ModuleConfiguration moduleConfiguration, + @NotNull ModuleDescriptor module, @NotNull LookupMode lookupMode ) { if (importDirective.isAbsoluteInRootNamespace()) { @@ -94,7 +93,7 @@ public class QualifiedExpressionResolver { } for (DeclarationDescriptor descriptor : descriptors) { - importer.addAllUnderImport(descriptor, moduleConfiguration.getPlatformToKotlinClassMap()); + importer.addAllUnderImport(descriptor, module.getPlatformToKotlinClassMap()); } return Collections.emptyList(); } 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 3f9b71fc5fd..2063ddc5d4d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -161,7 +161,7 @@ public class TopDownAnalyzer { Predicates.alwaysFalse(), true, false, Collections.emptyList()); InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( project, topDownAnalysisParameters, new ObservableBindingTrace(trace), - KotlinBuiltIns.getInstance().getBuiltInsModule(), ModuleConfiguration.EMPTY); + KotlinBuiltIns.getInstance().getBuiltInsModule()); injector.getTopDownAnalyzer().doProcessStandardLibraryNamespace(outerScope, standardLibraryNamespace, files); } @@ -194,8 +194,7 @@ public class TopDownAnalyzer { false, true, Collections.emptyList()); InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( - project, topDownAnalysisParameters, new ObservableBindingTrace(trace), moduleDescriptor, - ModuleConfiguration.EMPTY); + project, topDownAnalysisParameters, new ObservableBindingTrace(trace), moduleDescriptor); injector.getTopDownAnalyzer().doProcess(outerScope, new NamespaceLikeBuilder() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java index b3f5ec37689..61f7a61f92c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java @@ -19,11 +19,7 @@ package org.jetbrains.jet.lang.resolve; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -46,7 +42,7 @@ public class TypeResolver { private AnnotationResolver annotationResolver; private DescriptorResolver descriptorResolver; private QualifiedExpressionResolver qualifiedExpressionResolver; - private ModuleConfiguration moduleConfiguration; + private ModuleDescriptor moduleDescriptor; @Inject public void setDescriptorResolver(DescriptorResolver descriptorResolver) { @@ -64,8 +60,8 @@ public class TypeResolver { } @Inject - public void setModuleConfiguration(@NotNull ModuleConfiguration moduleConfiguration) { - this.moduleConfiguration = moduleConfiguration; + public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) { + this.moduleDescriptor = moduleDescriptor; } @NotNull @@ -333,7 +329,7 @@ public class TypeResolver { Collection descriptors = qualifiedExpressionResolver.lookupDescriptorsForUserType(userType, scope, trace); for (DeclarationDescriptor descriptor : descriptors) { if (descriptor instanceof ClassifierDescriptor) { - ImportsResolver.reportPlatformClassMappedToKotlin(moduleConfiguration, trace, userType, descriptor); + ImportsResolver.reportPlatformClassMappedToKotlin(moduleDescriptor, trace, userType, descriptor); return (ClassifierDescriptor) descriptor; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java index f701bbc2efa..d7e8b81ecaa 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java @@ -18,7 +18,6 @@ package org.jetbrains.jet.lang.resolve.lazy; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; @@ -32,9 +31,6 @@ import org.jetbrains.jet.lang.resolve.name.Name; public interface KotlinCodeAnalyzer { ModuleDescriptor getRootModuleDescriptor(); - @NotNull - ModuleConfiguration getModuleConfiguration(); - @Nullable NamespaceDescriptor getPackageDescriptor(@NotNull Name shortName); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java index 3f00a4a9415..b57418678ae 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java @@ -171,7 +171,7 @@ public class LazyImportScope implements JetScope { packageDescriptor.getMemberScope(), importer, traceForImportResolve, - resolveSession.getModuleConfiguration(), + resolveSession.getRootModuleDescriptor(), lookupMode); } finally { 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 90a202f98f5..6447e6dc929 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 @@ -25,11 +25,12 @@ import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.di.InjectorForLazyResolve; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider; import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor; @@ -65,18 +66,16 @@ public class ResolveSession implements KotlinCodeAnalyzer { private final InjectorForLazyResolve injector; - private final ModuleConfiguration moduleConfiguration; private final Function classifierAliases; public ResolveSession( - @NotNull Project project, - @NotNull StorageManager storageManager, - @NotNull ModuleDescriptorImpl rootDescriptor, - @NotNull ModuleConfiguration moduleConfiguration, - @NotNull DeclarationProviderFactory declarationProviderFactory + @NotNull Project project, + @NotNull StorageManager storageManager, + @NotNull ModuleDescriptorImpl rootDescriptor, + @NotNull DeclarationProviderFactory declarationProviderFactory ) { - this(project, storageManager, rootDescriptor, moduleConfiguration, declarationProviderFactory, NO_ALIASES, + this(project, storageManager, rootDescriptor, declarationProviderFactory, NO_ALIASES, Predicates.alwaysFalse(), new BindingTraceContext()); } @@ -85,14 +84,12 @@ public class ResolveSession implements KotlinCodeAnalyzer { @NotNull Project project, @NotNull StorageManager storageManager, @NotNull ModuleDescriptorImpl rootDescriptor, - @NotNull ModuleConfiguration moduleConfiguration, @NotNull DeclarationProviderFactory declarationProviderFactory, @NotNull BindingTrace delegationTrace ) { this(project, storageManager, rootDescriptor, - moduleConfiguration, declarationProviderFactory, NO_ALIASES, Predicates.alwaysFalse(), @@ -104,7 +101,6 @@ public class ResolveSession implements KotlinCodeAnalyzer { @NotNull Project project, @NotNull StorageManager storageManager, @NotNull ModuleDescriptorImpl rootDescriptor, - @NotNull ModuleConfiguration moduleConfiguration, @NotNull DeclarationProviderFactory declarationProviderFactory, @NotNull Function classifierAliases, @NotNull Predicate specialClasses, @@ -114,9 +110,8 @@ public class ResolveSession implements KotlinCodeAnalyzer { this.classifierAliases = classifierAliases; this.specialClasses = specialClasses; this.trace = storageManager.createSafeTrace(delegationTrace); - this.injector = new InjectorForLazyResolve(project, this, moduleConfiguration); + this.injector = new InjectorForLazyResolve(project, this, rootDescriptor); this.module = rootDescriptor; - this.moduleConfiguration = moduleConfiguration; PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(FqName.ROOT); assert provider != null : "No declaration provider for root package in " + rootDescriptor; this.rootPackage = new LazyPackageDescriptor(rootDescriptor, FqNameUnsafe.ROOT_NAME, this, provider); @@ -144,12 +139,6 @@ public class ResolveSession implements KotlinCodeAnalyzer { return storageManager; } - @Override - @NotNull - public ModuleConfiguration getModuleConfiguration() { - return moduleConfiguration; - } - @Override @Nullable public NamespaceDescriptor getPackageDescriptor(@NotNull Name shortName) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java index 936d9c2b1fd..3ec28b87236 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java @@ -26,7 +26,6 @@ import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.di.InjectorForBodyResolve; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorBase; import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor; @@ -161,7 +160,7 @@ public class ResolveSessionUtils { private static void delegationSpecifierAdditionalResolve( KotlinCodeAnalyzer analyzer, JetDelegationSpecifierList specifier, DelegatingBindingTrace trace, JetFile file) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getModuleConfiguration()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getRootModuleDescriptor()); JetClassOrObject classOrObject = (JetClassOrObject) specifier.getParent(); LazyClassDescriptor descriptor = (LazyClassDescriptor) analyzer.resolveToDescriptor(classOrObject); @@ -186,7 +185,7 @@ public class ResolveSessionUtils { return propertyResolutionScope; } }); - BodyResolver bodyResolver = createBodyResolver(trace, file, bodyResolveContext, resolveSession.getModuleConfiguration()); + BodyResolver bodyResolver = createBodyResolver(trace, file, bodyResolveContext, resolveSession.getRootModuleDescriptor()); PropertyDescriptor descriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(jetProperty); JetExpression propertyInitializer = jetProperty.getInitializer(); @@ -204,7 +203,7 @@ public class ResolveSessionUtils { DelegatingBindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getModuleConfiguration()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getRootModuleDescriptor()); JetScope scope = resolveSession.getInjector().getScopeProvider().getResolutionScopeForDeclaration(namedFunction); FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction); bodyResolver.resolveFunctionBody(trace, namedFunction, functionDescriptor, scope); @@ -216,7 +215,7 @@ public class ResolveSessionUtils { DelegatingBindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getModuleConfiguration()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getRootModuleDescriptor()); JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class); LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) analyzer.resolveToDescriptor(classOrObject); bodyResolver.resolveAnonymousInitializers(classOrObject, classOrObjectDescriptor.getUnsubstitutedPrimaryConstructor(), @@ -226,19 +225,19 @@ public class ResolveSessionUtils { } private static BodyResolver createBodyResolver(DelegatingBindingTrace trace, JetFile file, BodyResolveContextForLazy bodyResolveContext, - ModuleConfiguration moduleConfiguration) { + ModuleDescriptor module) { TopDownAnalysisParameters parameters = new TopDownAnalysisParameters( Predicates.alwaysTrue(), false, true, Collections.emptyList()); - InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(file.getProject(), parameters, trace, bodyResolveContext, moduleConfiguration); + InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(file.getProject(), parameters, trace, bodyResolveContext, module); return bodyResolve.getBodyResolver(); } private static BodyResolver createBodyResolverWithEmptyContext( DelegatingBindingTrace trace, JetFile file, - ModuleConfiguration moduleConfiguration + ModuleDescriptor module ) { - return createBodyResolver(trace, file, EMPTY_CONTEXT, moduleConfiguration); + return createBodyResolver(trace, file, EMPTY_CONTEXT, module); } private static JetScope getExpressionResolutionScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java index e1e26923bfa..8fcf68546cf 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java @@ -99,7 +99,7 @@ public class ScopeProvider { } JetImportsFactory importsFactory = resolveSession.getInjector().getJetImportsFactory(); - List defaultImports = resolveSession.getModuleConfiguration().getDefaultImports(); + List defaultImports = resolveSession.getRootModuleDescriptor().getDefaultImports(); Collection defaultImportDirectives = importsFactory.createImportDirectives(defaultImports); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageDescriptor.java index c7868fa5cb5..2d0b9d202de 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageDescriptor.java @@ -45,7 +45,7 @@ public class LazyPackageDescriptor extends AbstractNamespaceDescriptorImpl imple super(containingDeclaration, Collections.emptyList(), name); WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, "Package scope"); - resolveSession.getModuleConfiguration().extendNamespaceScope(resolveSession.getTrace(), this, scope); + resolveSession.getRootModuleDescriptor().getModuleConfiguration().extendNamespaceScope(resolveSession.getTrace(), this, scope); scope.changeLockLevel(WritableScope.LockLevel.READING); this.lazyScope = new LazyPackageMemberScope(resolveSession, declarationProvider, this); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java index 19263b980ae..3a7fb538e13 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java @@ -309,5 +309,9 @@ public class ErrorUtils { } } + public static ModuleDescriptor getErrorModule() { + return ERROR_MODULE; + } + private ErrorUtils() {} } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 8cabe24a372..3e69304c80c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -244,12 +244,12 @@ public class ExpressionTypingUtils { @NotNull JetExpression receiverExpression, @NotNull JetType receiverType, @NotNull JetScope scope, - @NotNull ModuleConfiguration moduleConfiguration + @NotNull ModuleDescriptor module ) { JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, callableFQN.getFqName()); Collection declarationDescriptors = new QualifiedExpressionResolver() - .analyseImportReference(importDirective, scope, new BindingTraceContext(), moduleConfiguration); + .analyseImportReference(importDirective, scope, new BindingTraceContext(), module); List callableExtensionDescriptors = new ArrayList(); ReceiverValue receiverValue = new ExpressionReceiver(receiverExpression, receiverType); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java index 0d9612c99b9..3b6b34984fb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java @@ -229,7 +229,6 @@ public class KotlinBuiltIns { project, storageManager, builtInsModule, - SpecialModuleConfiguration.INSTANCE, new FileBasedDeclarationProviderFactory(storageManager, files), ResolveSession.NO_ALIASES, Predicates.in(Sets.newHashSet(new FqNameUnsafe("jet.Any"), new FqNameUnsafe("jet.Nothing"))), diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index 09f0f4d8ac2..1113db2b6b8 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -39,6 +39,9 @@ import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.jet.codegen.forTestCompile.ForTestPackJdkAnnotations; import org.jetbrains.jet.config.CommonConfigurationKeys; import org.jetbrains.jet.config.CompilerConfiguration; +import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.diagnostics.Severity; @@ -50,6 +53,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil; +import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.plugin.JetLanguage; import org.jetbrains.jet.test.InnerTestClasses; import org.jetbrains.jet.test.TestMetadata; @@ -553,4 +557,10 @@ public class JetTestUtils { String text = FileUtil.loadFile(ioFile); return JetPsiFactory.createPhysicalFile(project, ioFile.getName(), text); } + + public static ModuleDescriptor createEmptyModule() { + ModuleDescriptorImpl descriptor = new ModuleDescriptorImpl(Name.special("")); + descriptor.setModuleConfiguration(ModuleConfiguration.EMPTY); + return descriptor; + } } diff --git a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java index b8223cb44aa..80be3fe32cd 100644 --- a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java @@ -21,8 +21,8 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.lang.ModuleConfiguration; import com.intellij.openapi.project.Project; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; @@ -39,8 +39,8 @@ public class InjectorForTests { private TypeResolver typeResolver; private CallResolver callResolver; private KotlinBuiltIns kotlinBuiltIns; - private ModuleConfiguration moduleConfiguration; private final Project project; + private final ModuleDescriptor moduleDescriptor; private AnnotationResolver annotationResolver; private CallExpressionResolver callExpressionResolver; private QualifiedExpressionResolver qualifiedExpressionResolver; @@ -48,15 +48,16 @@ public class InjectorForTests { private CandidateResolver candidateResolver; public InjectorForTests( - @NotNull Project project + @NotNull Project project, + @NotNull ModuleDescriptor moduleDescriptor ) { this.descriptorResolver = new DescriptorResolver(); this.expressionTypingServices = new ExpressionTypingServices(); this.typeResolver = new TypeResolver(); this.callResolver = new CallResolver(); this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); - this.moduleConfiguration = ModuleConfiguration.EMPTY; this.project = project; + this.moduleDescriptor = moduleDescriptor; this.annotationResolver = new AnnotationResolver(); this.callExpressionResolver = new CallExpressionResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); @@ -75,7 +76,7 @@ public class InjectorForTests { this.typeResolver.setAnnotationResolver(annotationResolver); this.typeResolver.setDescriptorResolver(descriptorResolver); - this.typeResolver.setModuleConfiguration(moduleConfiguration); + this.typeResolver.setModuleDescriptor(moduleDescriptor); this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); this.callResolver.setArgumentTypeResolver(argumentTypeResolver); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index f64a0179965..388ca0ede58 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java @@ -153,7 +153,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { Predicates.alwaysFalse(), false, false, Collections.emptyList()), trace, moduleDescriptor); - moduleDescriptor.setModuleConfiguration(injectorForAnalyzer.getModuleConfiguration()); + moduleDescriptor.setModuleConfiguration(injectorForAnalyzer.getJavaBridgeConfiguration()); injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(environment.getSourceFiles(), Collections.emptyList()); 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 6fdac1bef6d..1b86accbe57 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -55,10 +55,10 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe Collection files = Lists.newArrayList(psiFile); ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("")); - lazyModule.setModuleConfiguration(injectorForTopDownAnalyzer.getModuleConfiguration()); + lazyModule.setModuleConfiguration(injectorForTopDownAnalyzer.getModuleDescriptor().getModuleConfiguration()); LockBasedStorageManager storageManager = new LockBasedStorageManager(); - final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(), - new FileBasedDeclarationProviderFactory(storageManager, files)); + final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule, + new FileBasedDeclarationProviderFactory(storageManager, files)); final List descriptors = new ArrayList(); psiFile.accept(new JetVisitorVoid() { 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 42fd6eaf573..6cec425065d 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -63,7 +63,6 @@ public class LazyResolveTestUtil { ModuleDescriptorImpl eagerModuleForLazy = new ModuleDescriptorImpl(Name.special("")); InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy, environment); - eagerModuleForLazy.setModuleConfiguration(tdaInjectorForLazy.getModuleConfiguration()); // This line is required fro the 'jet' namespace to be filled in with functions tdaInjectorForLazy.getTopDownAnalyzer().analyzeFiles( Collections.singletonList(JetPsiFactory.createFile(environment.getProject(), "")), Collections.emptyList()); @@ -76,13 +75,14 @@ public class LazyResolveTestUtil { TopDownAnalysisParameters params = new TopDownAnalysisParameters( Predicates.alwaysTrue(), false, false, Collections.emptyList()); BindingTrace sharedTrace = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()).getTrace(); - return new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, module); + InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, module); + module.setModuleConfiguration(injector.getJavaBridgeConfiguration()); + return injector; } public static ModuleDescriptor resolveEagerly(List files, JetCoreEnvironment environment) { ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("")); InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment); - module.setModuleConfiguration(injector.getModuleConfiguration()); injector.getTopDownAnalyzer().analyzeFiles(files, Collections.emptyList()); return module; } @@ -143,7 +143,7 @@ public class LazyResolveTestUtil { ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("")); lazyModule.setModuleConfiguration(moduleConfiguration); - return new ResolveSession(project, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory, sharedTrace); + return new ResolveSession(project, storageManager, lazyModule, declarationProviderFactory, sharedTrace); } public static ModuleDescriptor resolveLazily(List files, JetCoreEnvironment environment) { diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java b/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java index b05c6065506..cb3913a35e2 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java @@ -20,12 +20,10 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.*; import junit.framework.Assert; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.di.InjectorForTests; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition; @@ -129,7 +127,8 @@ public class JetExpectedResolveDataUtil { Project project, JetType... parameterTypes ) { - ExpressionTypingServices expressionTypingServices = new InjectorForTests(project).getExpressionTypingServices(); + ModuleDescriptor emptyModule = JetTestUtils.createEmptyModule(); + ExpressionTypingServices expressionTypingServices = new InjectorForTests(project, emptyModule).getExpressionTypingServices(); ExpressionTypingContext context = ExpressionTypingContext.newContext( expressionTypingServices, new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(), diff --git a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java index 2cfe8e9a911..ab25f948be8 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java @@ -65,7 +65,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { private JetScope scope; public void setUp() throws Exception { - InjectorForTests injector = new InjectorForTests(getProject()); + InjectorForTests injector = new InjectorForTests(getProject(), root); KotlinBuiltIns builtIns = injector.getKotlinBuiltIns(); descriptorResolver = injector.getDescriptorResolver(); scope = createScope(builtIns.getBuiltInsScope()); diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java index dc533817232..e6ccd6d0821 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java @@ -46,7 +46,7 @@ public class JetOverloadTest extends JetLiteFixture { @Override public void setUp() throws Exception { super.setUp(); - InjectorForTests injector = new InjectorForTests(getProject()); + InjectorForTests injector = new InjectorForTests(getProject(), root); builtIns = injector.getKotlinBuiltIns(); descriptorResolver = injector.getDescriptorResolver(); } diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java index 139ff850bfd..581cbee19bc 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java @@ -46,7 +46,7 @@ public class JetOverridingTest extends JetLiteFixture { @Override public void setUp() throws Exception { super.setUp(); - InjectorForTests injector = new InjectorForTests(getProject()); + InjectorForTests injector = new InjectorForTests(getProject(), root); builtIns = injector.getKotlinBuiltIns(); descriptorResolver = injector.getDescriptorResolver(); } diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index f66ed6303c8..3655ebfd286 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -79,7 +79,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { builtIns = KotlinBuiltIns.getInstance(); - InjectorForTests injector = new InjectorForTests(getProject()); + InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule()); descriptorResolver = injector.getDescriptorResolver(); typeResolver = injector.getTypeResolver(); expressionTypingServices = injector.getExpressionTypingServices(); diff --git a/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java b/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java index d2f25ae6bad..9e0ace47cc3 100644 --- a/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java +++ b/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java @@ -24,6 +24,7 @@ import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForTests; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; @@ -65,7 +66,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment { protected void setUp() throws Exception { super.setUp(); - injector = new InjectorForTests(getProject()); + injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule()); scope = getContextScope(); } diff --git a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index 08b2d4b647d..e38c1b6c5bd 100644 --- a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java @@ -27,8 +27,6 @@ import org.jetbrains.jet.codegen.state.JetTypeMapper; import org.jetbrains.jet.di.DependencyInjectorGenerator; import org.jetbrains.jet.di.GivenExpression; import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; -import org.jetbrains.jet.di.InstantiateType; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetImportsFactory; @@ -70,7 +68,7 @@ public class GenerateInjectors { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(); generator.addParameter(Project.class); generator.addParameter(ResolveSession.class); - generator.addParameter(ModuleConfiguration.class); + generator.addParameter(ModuleDescriptor.class); generator.addPublicField(DescriptorResolver.class); generator.addPublicField(ExpressionTypingServices.class); generator.addPublicField(TypeResolver.class); @@ -84,7 +82,6 @@ public class GenerateInjectors { private static void generateInjectorForTopDownAnalyzerBasic() throws IOException { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(); generateInjectorForTopDownAnalyzerCommon(generator); - generator.addParameter(ModuleConfiguration.class); generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class); generator.addField(NamespaceFactoryImpl.class); generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic", GenerateInjectors.class); @@ -93,7 +90,6 @@ public class GenerateInjectors { private static void generateInjectorForTopDownAnalyzerForJs() throws IOException { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(); generateInjectorForTopDownAnalyzerCommon(generator); - generator.addPublicParameter(ModuleConfiguration.class); generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class); generator.addField(NamespaceFactoryImpl.class); generator.generate("js/js.translator/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs", GenerateInjectors.class); @@ -103,7 +99,7 @@ public class GenerateInjectors { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(); generator.implementInterface(InjectorForTopDownAnalyzer.class); generateInjectorForTopDownAnalyzerCommon(generator); - generator.addField(true, ModuleConfiguration.class, null, new InstantiateType(JavaBridgeConfiguration.class)); + generator.addPublicField(JavaBridgeConfiguration.class); generator.addField(JavaDescriptorResolver.class); generator.addField(PsiClassFinderImpl.class); generator.addPublicField(NamespaceFactoryImpl.class); @@ -142,7 +138,7 @@ public class GenerateInjectors { generator.addPublicParameter(Project.class); generator.addPublicParameter(TopDownAnalysisParameters.class); generator.addPublicParameter(BindingTrace.class); - generator.addParameter(ModuleDescriptorImpl.class); + generator.addPublicParameter(ModuleDescriptorImpl.class); } private static void generateMacroInjector() throws IOException { @@ -153,7 +149,7 @@ public class GenerateInjectors { // Parameters generator.addPublicParameter(Project.class); - generator.addParameter(ModuleConfiguration.class); + generator.addParameter(ModuleDescriptor.class); generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForMacros", GenerateInjectors.class); } @@ -167,10 +163,10 @@ public class GenerateInjectors { generator.addPublicField(TypeResolver.class); generator.addPublicField(CallResolver.class); generator.addField(true, KotlinBuiltIns.class, null, new GivenExpression("KotlinBuiltIns.getInstance()")); - generator.addField(false, ModuleConfiguration.class, null, new GivenExpression("ModuleConfiguration.EMPTY")); // Parameters generator.addPublicParameter(Project.class); + generator.addParameter(ModuleDescriptor.class); generator.generate("compiler/tests", "org.jetbrains.jet.di", "InjectorForTests", GenerateInjectors.class); } @@ -229,7 +225,7 @@ public class GenerateInjectors { generator.addPublicParameter(TopDownAnalysisParameters.class); generator.addPublicParameter(BindingTrace.class); generator.addPublicParameter(BodiesResolveContext.class); - generator.addParameter(ModuleConfiguration.class); + generator.addParameter(ModuleDescriptor.class); generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForBodyResolve", GenerateInjectors.class); } } diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java index 7f0ff49e756..2993f177059 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java @@ -236,7 +236,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { if (functionFQN != null) { JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, new ImportPath(functionFQN, false)); Collection declarationDescriptors = new QualifiedExpressionResolver().analyseImportReference( - importDirective, jetScope, new BindingTraceContext(), resolveSession.getModuleConfiguration()); + importDirective, jetScope, new BindingTraceContext(), resolveSession.getRootModuleDescriptor()); for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) { if (declarationDescriptor instanceof FunctionDescriptor) { result.add((FunctionDescriptor) declarationDescriptor); @@ -335,7 +335,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { // Iterate through the function with attempt to resolve found functions for (FqName functionFQN : functionFQNs) { for (CallableDescriptor functionDescriptor : ExpressionTypingUtils.canFindSuitableCall( - functionFQN, project, receiverExpression, expressionType, scope, resolveSession.getModuleConfiguration())) { + functionFQN, project, receiverExpression, expressionType, scope, resolveSession.getRootModuleDescriptor())) { resultDescriptors.add(functionDescriptor); } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index 7e5a879c1cb..eebec2506d9 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -227,7 +227,6 @@ public class JetSourceNavigationHelper { project, storageManager, moduleDescriptor, - DefaultModuleConfiguration.createStandardConfiguration(), providerFactory); for (JetNamedDeclaration candidate : candidates) { diff --git a/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java b/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java index 04d1c2548d9..1292978124b 100644 --- a/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java +++ b/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java @@ -67,7 +67,7 @@ public abstract class BaseJetVariableMacro extends Macro { return null; } - ExpressionTypingServices callResolverContext = new InjectorForMacros(project, analyzeExhaust.getModuleConfiguration()).getExpressionTypingServices(); + ExpressionTypingServices callResolverContext = new InjectorForMacros(project, analyzeExhaust.getModuleDescriptor()).getExpressionTypingServices(); List filteredDescriptors = new ArrayList(); for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) { diff --git a/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java b/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java index 93e6080a396..74d4edd466e 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java +++ b/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java @@ -38,7 +38,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.asJava.LightClassUtil; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.JetFile; @@ -46,6 +45,7 @@ import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.JetFilesProvider; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; +import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil; import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCache; import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCacheImpl; @@ -121,7 +121,7 @@ public final class AnalyzerFacadeWithCache { } private static AnalyzeExhaust emptyExhaust() { - return AnalyzeExhaust.success(BindingContext.EMPTY, ModuleConfiguration.EMPTY); + return AnalyzeExhaust.success(BindingContext.EMPTY, ErrorUtils.getErrorModule()); } private static AnalyzeExhaust analyzeHeadersWithCacheOnFile(@NotNull JetFile fileToCache) { @@ -143,7 +143,6 @@ public final class AnalyzerFacadeWithCache { private static AnalyzeExhaust analyzeBodies(AnalyzeExhaust analyzeExhaustHeaders, JetFile file) { BodiesResolveContext context = analyzeExhaustHeaders.getBodiesResolveContext(); - ModuleConfiguration moduleConfiguration = analyzeExhaustHeaders.getModuleConfiguration(); assert context != null : "Headers resolver should prepare and stored information for bodies resolve"; // Need to resolve bodies in given file and all in the same package @@ -154,7 +153,7 @@ public final class AnalyzerFacadeWithCache { new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext(), "trace to resolve bodies in file", file.getName()), context, - moduleConfiguration); + analyzeExhaustHeaders.getModuleDescriptor()); } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/project/JSAnalyzerFacadeForIDEA.java b/idea/src/org/jetbrains/jet/plugin/project/JSAnalyzerFacadeForIDEA.java index 76f7f89c212..e35742b0669 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/JSAnalyzerFacadeForIDEA.java +++ b/idea/src/org/jetbrains/jet/plugin/project/JSAnalyzerFacadeForIDEA.java @@ -22,7 +22,7 @@ import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.analyzer.AnalyzerFacade; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -59,9 +59,9 @@ public enum JSAnalyzerFacadeForIDEA implements AnalyzerFacade { @NotNull Predicate filesForBodiesResolve, @NotNull BindingTrace traceContext, @NotNull BodiesResolveContext bodiesResolveContext, - @NotNull ModuleConfiguration configuration + @NotNull ModuleDescriptor module ) { - return AnalyzerFacadeForJS.analyzeBodiesInFiles(filesForBodiesResolve, new IDEAConfig(project), traceContext, bodiesResolveContext, configuration); + return AnalyzerFacadeForJS.analyzeBodiesInFiles(filesForBodiesResolve, new IDEAConfig(project), traceContext, bodiesResolveContext, module); } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateSureInProjectFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateSureInProjectFix.java index 42bc7f5bf8a..2593d7aa247 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateSureInProjectFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateSureInProjectFix.java @@ -25,7 +25,6 @@ import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalyzeExhaust; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.*; @@ -155,7 +154,6 @@ public class MigrateSureInProjectFix extends JetIntentionAction { Predicates.alwaysFalse()); BodiesResolveContext context = analyzeExhaustHeaders.getBodiesResolveContext(); - ModuleConfiguration moduleConfiguration = analyzeExhaustHeaders.getModuleConfiguration(); assert context != null : "Headers resolver should prepare and stored information for bodies resolve"; // Need to resolve bodies in given file and all in the same package @@ -165,6 +163,6 @@ public class MigrateSureInProjectFix extends JetIntentionAction { Predicates.alwaysTrue(), new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext(), "trace in migrate sure fix"), context, - moduleConfiguration); + analyzeExhaustHeaders.getModuleDescriptor()); } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java b/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java index 64253a5e1d4..82aee0fa8a7 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java @@ -31,7 +31,6 @@ import com.intellij.psi.PsiWhiteSpace; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.refactoring.HelpID; import com.intellij.refactoring.introduce.inplace.OccurrencesChooser; -import com.intellij.refactoring.util.CommonRefactoringUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalyzeExhaust; @@ -128,7 +127,7 @@ public class JetIntroduceVariableHandler extends JetIntroduceHandlerBase { } ObservableBindingTrace bindingTrace = new ObservableBindingTrace(new BindingTraceContext()); - InjectorForMacros injector = new InjectorForMacros(project, analyzeExhaust.getModuleConfiguration()); + InjectorForMacros injector = new InjectorForMacros(project, analyzeExhaust.getModuleDescriptor()); JetType typeNoExpectedType = injector.getExpressionTypingServices().getType(scope, expression, TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo, bindingTrace); diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 9a4e549ef13..3d823a2b021 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -26,7 +26,6 @@ import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.DeclarationResolver; @@ -61,7 +60,6 @@ public class InjectorForTopDownAnalyzerForJs { private final TopDownAnalysisParameters topDownAnalysisParameters; private final BindingTrace bindingTrace; private final ModuleDescriptorImpl moduleDescriptor; - private final ModuleConfiguration moduleConfiguration; private DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy; private NamespaceFactoryImpl namespaceFactory; private DeclarationResolver declarationResolver; @@ -85,8 +83,7 @@ public class InjectorForTopDownAnalyzerForJs { @NotNull Project project, @NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull BindingTrace bindingTrace, - @NotNull ModuleDescriptorImpl moduleDescriptor, - @NotNull ModuleConfiguration moduleConfiguration + @NotNull ModuleDescriptorImpl moduleDescriptor ) { this.topDownAnalyzer = new TopDownAnalyzer(); this.topDownAnalysisContext = new TopDownAnalysisContext(); @@ -98,7 +95,6 @@ public class InjectorForTopDownAnalyzerForJs { this.topDownAnalysisParameters = topDownAnalysisParameters; this.bindingTrace = bindingTrace; this.moduleDescriptor = moduleDescriptor; - this.moduleConfiguration = moduleConfiguration; this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl(); this.namespaceFactory = new NamespaceFactoryImpl(); this.declarationResolver = new DeclarationResolver(); @@ -150,7 +146,6 @@ public class InjectorForTopDownAnalyzerForJs { this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); this.descriptorResolver.setTypeResolver(typeResolver); - namespaceFactory.setConfiguration(moduleConfiguration); namespaceFactory.setModuleDescriptor(moduleDescriptor); namespaceFactory.setTrace(bindingTrace); @@ -182,14 +177,14 @@ public class InjectorForTopDownAnalyzerForJs { typeResolver.setAnnotationResolver(annotationResolver); typeResolver.setDescriptorResolver(descriptorResolver); - typeResolver.setModuleConfiguration(moduleConfiguration); + typeResolver.setModuleDescriptor(moduleDescriptor); typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); - importsResolver.setConfiguration(moduleConfiguration); importsResolver.setContext(topDownAnalysisContext); importsResolver.setImportsFactory(jetImportsFactory); + importsResolver.setModuleDescriptor(moduleDescriptor); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); @@ -261,8 +256,8 @@ public class InjectorForTopDownAnalyzerForJs { return this.bindingTrace; } - public ModuleConfiguration getModuleConfiguration() { - return this.moduleConfiguration; + public ModuleDescriptorImpl getModuleDescriptor() { + return this.moduleDescriptor; } } 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 436e02cc291..32750e4df96 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -25,13 +25,13 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager; -import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.k2js.config.Config; @@ -87,10 +87,8 @@ public final class AnalyzerFacadeForJS { BindingTrace trace = libraryBindingContext == null ? new ObservableBindingTrace(new BindingTraceContext()) : new DelegatingBindingTrace(libraryBindingContext, "trace for analyzing library in js"); - InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( - project, topDownAnalysisParameters, trace, owner, - new JsConfiguration(libraryBindingContext)); - owner.setModuleConfiguration(injector.getModuleConfiguration()); + owner.setModuleConfiguration(new JsConfiguration(libraryBindingContext)); + InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(project, topDownAnalysisParameters, trace, owner); try { Collection allFiles = libraryBindingContext != null ? files : @@ -99,7 +97,7 @@ public final class AnalyzerFacadeForJS { BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ? new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) : null; - return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, injector.getModuleConfiguration()); + return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, owner); } finally { injector.destroy(); @@ -112,12 +110,12 @@ public final class AnalyzerFacadeForJS { @NotNull Config config, @NotNull BindingTrace traceContext, @NotNull BodiesResolveContext bodiesResolveContext, - @NotNull ModuleConfiguration configuration) { + @NotNull ModuleDescriptor module) { Predicate completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely); return AnalyzerFacadeForEverything.analyzeBodiesInFilesWithJavaIntegration( config.getProject(), Collections.emptyList(), completely, traceContext, bodiesResolveContext, - configuration); + module); } public static void checkForErrors(@NotNull Collection allFiles, @NotNull BindingContext bindingContext) { @@ -146,6 +144,6 @@ public final class AnalyzerFacadeForJS { storageManager, Config.withJsLibAdded(files, config), Predicates.alwaysFalse()); ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("")); lazyModule.setModuleConfiguration(new JsConfiguration(null)); - return new ResolveSession(config.getProject(), storageManager, lazyModule, lazyModule.getModuleConfiguration(), declarationProviderFactory); + return new ResolveSession(config.getProject(), storageManager, lazyModule, declarationProviderFactory); } }