diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java index 717907df7c2..d4ee2f1d44e 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java @@ -258,7 +258,7 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport public V get(ReadOnlySlice slice, K key) { V value = super.get(slice, key); - if (value == null) { + if (value == null && TopDownAnalysisParameters.LAZY) { if (BindingContext.FUNCTION == slice || BindingContext.VARIABLE == slice) { if (key instanceof JetDeclaration) { JetDeclaration jetDeclaration = (JetDeclaration) key; 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 e85c02a3757..9dfe01733b1 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationRe import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl; import org.jetbrains.jet.lang.resolve.java.sam.SamConversionResolverImpl; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl; +import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver; import org.jetbrains.jet.lang.resolve.java.JavaLazyAnalyzerPostConstruct; import org.jetbrains.jet.lang.resolve.java.JavaFlexibleTypeCapabilitiesProvider; @@ -73,6 +74,9 @@ import org.jetbrains.jet.lang.resolve.ImportsResolver; import org.jetbrains.jet.lang.psi.JetImportsFactory; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext; @@ -108,6 +112,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator; private final SamConversionResolverImpl samConversionResolver; private final JavaSourceElementFactoryImpl javaSourceElementFactory; + private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final SingleModuleClassResolver singleModuleClassResolver; private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct; private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider; @@ -143,6 +148,9 @@ public class InjectorForTopDownAnalyzerForJvm { private final JetImportsFactory jetImportsFactory; private final OverloadResolver overloadResolver; private final OverrideResolver overrideResolver; + private final TopDownAnalyzer topDownAnalyzer; + private final TypeHierarchyResolver typeHierarchyResolver; + private final ScriptHeaderResolver scriptHeaderResolver; private final ScopeProvider scopeProvider; private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; private final GlobalJavaResolverContext globalJavaResolverContext; @@ -186,6 +194,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver); this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, virtualFileFinder, traceBasedErrorReporter); this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider); + this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module); this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct(); this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider(); this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$; @@ -220,6 +229,9 @@ public class InjectorForTopDownAnalyzerForJvm { this.jetImportsFactory = new JetImportsFactory(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); + this.topDownAnalyzer = new TopDownAnalyzer(); + this.typeHierarchyResolver = new TypeHierarchyResolver(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); this.scopeProvider = new ScopeProvider(getResolveSession()); this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver); @@ -228,6 +240,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.lazyTopDownAnalyzer.setModuleDescriptor(module); this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); + this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer); this.lazyTopDownAnalyzer.setTrace(bindingTrace); this.resolveSession.setAnnotationResolve(annotationResolver); @@ -345,6 +358,23 @@ public class InjectorForTopDownAnalyzerForJvm { overrideResolver.setTrace(bindingTrace); + topDownAnalyzer.setBodyResolver(bodyResolver); + topDownAnalyzer.setDeclarationResolver(declarationResolver); + topDownAnalyzer.setModuleDescriptor(module); + topDownAnalyzer.setOverloadResolver(overloadResolver); + topDownAnalyzer.setOverrideResolver(overrideResolver); + topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider); + topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); + + typeHierarchyResolver.setDescriptorResolver(descriptorResolver); + typeHierarchyResolver.setImportsResolver(importsResolver); + typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); + typeHierarchyResolver.setTrace(bindingTrace); + + scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + scriptHeaderResolver.setTrace(bindingTrace); + deserializedDescriptorResolver.setComponents(deserializationComponentsForJava); javaClassFinder.initialize(); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java index d615a6f2f77..91dd471cdad 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java @@ -57,6 +57,10 @@ import org.jetbrains.jet.lang.resolve.ImportsResolver; import org.jetbrains.jet.lang.psi.JetImportsFactory; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; +import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -105,6 +109,10 @@ public class InjectorForLazyBodyResolve { private final JetImportsFactory jetImportsFactory; private final OverloadResolver overloadResolver; private final OverrideResolver overrideResolver; + private final TopDownAnalyzer topDownAnalyzer; + private final MutablePackageFragmentProvider mutablePackageFragmentProvider; + private final TypeHierarchyResolver typeHierarchyResolver; + private final ScriptHeaderResolver scriptHeaderResolver; public InjectorForLazyBodyResolve( @NotNull Project project, @@ -154,6 +162,10 @@ public class InjectorForLazyBodyResolve { this.jetImportsFactory = new JetImportsFactory(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); + this.topDownAnalyzer = new TopDownAnalyzer(); + this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(moduleDescriptor); + this.typeHierarchyResolver = new TypeHierarchyResolver(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver); this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver); @@ -161,6 +173,7 @@ public class InjectorForLazyBodyResolve { this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor); this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); + this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer); this.lazyTopDownAnalyzer.setTrace(bindingTrace); bodyResolver.setAnnotationResolver(annotationResolver); @@ -249,6 +262,23 @@ public class InjectorForLazyBodyResolve { overrideResolver.setTrace(bindingTrace); + topDownAnalyzer.setBodyResolver(bodyResolver); + topDownAnalyzer.setDeclarationResolver(declarationResolver); + topDownAnalyzer.setModuleDescriptor(moduleDescriptor); + topDownAnalyzer.setOverloadResolver(overloadResolver); + topDownAnalyzer.setOverrideResolver(overrideResolver); + topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider); + topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); + + typeHierarchyResolver.setDescriptorResolver(descriptorResolver); + typeHierarchyResolver.setImportsResolver(importsResolver); + typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); + typeHierarchyResolver.setTrace(bindingTrace); + + scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + scriptHeaderResolver.setTrace(bindingTrace); + } @PreDestroy diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java index 72b01b79a85..549974d91ad 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java @@ -59,6 +59,10 @@ import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; +import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -109,6 +113,10 @@ public class InjectorForLazyTopDownAnalyzerBasic { private final ImportsResolver importsResolver; private final OverloadResolver overloadResolver; private final OverrideResolver overrideResolver; + private final TopDownAnalyzer topDownAnalyzer; + private final MutablePackageFragmentProvider mutablePackageFragmentProvider; + private final TypeHierarchyResolver typeHierarchyResolver; + private final ScriptHeaderResolver scriptHeaderResolver; public InjectorForLazyTopDownAnalyzerBasic( @NotNull Project project, @@ -160,6 +168,10 @@ public class InjectorForLazyTopDownAnalyzerBasic { this.importsResolver = new ImportsResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); + this.topDownAnalyzer = new TopDownAnalyzer(); + this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(moduleDescriptor); + this.typeHierarchyResolver = new TypeHierarchyResolver(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); @@ -175,6 +187,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor); this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); + this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer); this.lazyTopDownAnalyzer.setTrace(bindingTrace); annotationResolver.setCallResolver(callResolver); @@ -263,6 +276,23 @@ public class InjectorForLazyTopDownAnalyzerBasic { overrideResolver.setTrace(bindingTrace); + topDownAnalyzer.setBodyResolver(bodyResolver); + topDownAnalyzer.setDeclarationResolver(declarationResolver); + topDownAnalyzer.setModuleDescriptor(moduleDescriptor); + topDownAnalyzer.setOverloadResolver(overloadResolver); + topDownAnalyzer.setOverrideResolver(overrideResolver); + topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider); + topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); + + typeHierarchyResolver.setDescriptorResolver(descriptorResolver); + typeHierarchyResolver.setImportsResolver(importsResolver); + typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); + typeHierarchyResolver.setTrace(bindingTrace); + + scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + scriptHeaderResolver.setTrace(bindingTrace); + } @PreDestroy diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index b09bd38653c..8bdc2b64cca 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -161,15 +161,12 @@ public class InjectorForTopDownAnalyzerBasic { this.typeHierarchyResolver = new TypeHierarchyResolver(); this.scriptHeaderResolver = new ScriptHeaderResolver(); - this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); this.topDownAnalyzer.setOverloadResolver(overloadResolver); this.topDownAnalyzer.setOverrideResolver(overrideResolver); this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider); - this.topDownAnalyzer.setProject(project); - this.topDownAnalyzer.setTrace(bindingTrace); this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); bodyResolver.setAnnotationResolver(annotationResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java index 42590dfef88..8e2bcc6da6b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java @@ -18,7 +18,6 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.HashMultimap; import com.google.common.collect.Multimap; -import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.util.PsiTreeUtil; import kotlin.KotlinPackage; @@ -72,6 +71,10 @@ public class LazyTopDownAnalyzer { @NotNull private BodyResolver bodyResolver = null; + @SuppressWarnings("ConstantConditions") + @NotNull + private TopDownAnalyzer topDownAnalyzer = null; + @Inject public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) { this.resolveSession = kotlinCodeAnalyzer; @@ -107,12 +110,23 @@ public class LazyTopDownAnalyzer { this.bodyResolver = bodyResolver; } + @Inject + public void setTopDownAnalyzer(@NotNull TopDownAnalyzer topDownAnalyzer) { + this.topDownAnalyzer = topDownAnalyzer; + } + @NotNull public TopDownAnalysisContext analyzeFiles( @NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull Collection files, @NotNull List additionalProviders ) { + if (!topDownAnalysisParameters.isLazy()) { + return topDownAnalyzer.analyzeFiles( + topDownAnalysisParameters, files, + additionalProviders.toArray(new PackageFragmentProvider[additionalProviders.size()])); + } + PackageFragmentProvider provider; if (additionalProviders.isEmpty()) { provider = resolveSession.getPackageFragmentProvider(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java index 40c4485c062..28908fc1ef4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java @@ -28,7 +28,8 @@ import org.jetbrains.jet.storage.StorageManager; * Various junk that cannot be placed into context (yet). */ public class TopDownAnalysisParameters extends LazinessToken implements GlobalContext { - private static boolean LAZY; + @Deprecated + public static final boolean LAZY; static { LAZY = !"false".equals(System.getProperty("lazy.tda")); 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 1cc34835fe5..4f101f7a521 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -17,12 +17,9 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Sets; -import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; -import kotlin.Function1; import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptorWithResolutionScopes; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider; @@ -33,34 +30,36 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import javax.inject.Inject; -import java.util.*; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import java.util.Set; +@Deprecated public class TopDownAnalyzer { - @NotNull - private BindingTrace trace; - @NotNull + @SuppressWarnings("NullableProblems") @NotNull private DeclarationResolver declarationResolver; - @NotNull - private TypeHierarchyResolver typeHierarchyResolver; - @NotNull - private OverrideResolver overrideResolver; - @NotNull - private OverloadResolver overloadResolver; - @NotNull - private ModuleDescriptor moduleDescriptor; - @NotNull - private MutablePackageFragmentProvider packageFragmentProvider; - @NotNull - private BodyResolver bodyResolver; - @NotNull - private AdditionalCheckerProvider additionalCheckerProvider; - @NotNull - private Project project; - @Inject - public void setTrace(@NotNull BindingTrace trace) { - this.trace = trace; + @SuppressWarnings("NullableProblems") @NotNull + private TypeHierarchyResolver typeHierarchyResolver; + + @SuppressWarnings("NullableProblems") @NotNull + private OverrideResolver overrideResolver; + + @SuppressWarnings("NullableProblems") @NotNull + private OverloadResolver overloadResolver; + + @SuppressWarnings("NullableProblems") @NotNull + private ModuleDescriptor moduleDescriptor; + + @SuppressWarnings("NullableProblems") @NotNull + private MutablePackageFragmentProvider packageFragmentProvider; + + @SuppressWarnings("NullableProblems") @NotNull + private BodyResolver bodyResolver; + + public TopDownAnalyzer() { } @Inject @@ -98,16 +97,6 @@ public class TopDownAnalyzer { this.bodyResolver = bodyResolver; } - @Inject - public void setProject(@NotNull Project project) { - this.project = project; - } - - @Inject - public void setAdditionalCheckerProvider(@NotNull AdditionalCheckerProvider additionalCheckerProvider) { - this.additionalCheckerProvider = additionalCheckerProvider; - } - public void doProcess( @NotNull TopDownAnalysisContext c, @NotNull JetScope outerScope, @@ -129,19 +118,10 @@ public class TopDownAnalyzer { } c.debug("Exit"); + //noinspection UseOfSystemOutOrSystemErr c.printDebugOutput(System.out); } - private static Collection getFiles(Collection declarations) { - return new LinkedHashSet(KotlinPackage.map(declarations, new Function1() { - @Nullable - @Override - public JetFile invoke(PsiElement element) { - return (JetFile) element.getContainingFile(); - } - })); - } - private void lockScopes(@NotNull TopDownAnalysisContext c) { for (ClassDescriptorWithResolutionScopes mutableClassDescriptor : c.getDeclaredClasses().values()) { ((MutableClassDescriptor) mutableClassDescriptor).lockScopes(); @@ -177,6 +157,7 @@ public class TopDownAnalyzer { @NotNull Collection files, @NotNull List additionalProviders ) { + //noinspection deprecation assert !topDownAnalysisParameters.isLazy() : "Lazy resolve must be disabled for this method"; TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters); diff --git a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index bc786022440..9ed11a38f88 100644 --- a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -59,6 +60,9 @@ import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -75,6 +79,7 @@ public class InjectorForTopDownAnalyzerForJs { private final DeclarationProviderFactory declarationProviderFactory; private final ResolveSession resolveSession; private final LazyTopDownAnalyzer lazyTopDownAnalyzer; + private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final AdditionalCheckerProvider additionalCheckerProvider; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -109,6 +114,9 @@ public class InjectorForTopDownAnalyzerForJs { private final ImportsResolver importsResolver; private final OverloadResolver overloadResolver; private final OverrideResolver overrideResolver; + private final TopDownAnalyzer topDownAnalyzer; + private final TypeHierarchyResolver typeHierarchyResolver; + private final ScriptHeaderResolver scriptHeaderResolver; public InjectorForTopDownAnalyzerForJs( @NotNull Project project, @@ -126,6 +134,7 @@ public class InjectorForTopDownAnalyzerForJs { this.declarationProviderFactory = declarationProviderFactory; this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace); this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); + this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module); this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty.INSTANCE$; this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -160,6 +169,9 @@ public class InjectorForTopDownAnalyzerForJs { this.importsResolver = new ImportsResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); + this.topDownAnalyzer = new TopDownAnalyzer(); + this.typeHierarchyResolver = new TypeHierarchyResolver(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); @@ -175,6 +187,7 @@ public class InjectorForTopDownAnalyzerForJs { this.lazyTopDownAnalyzer.setModuleDescriptor(module); this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); + this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer); this.lazyTopDownAnalyzer.setTrace(bindingTrace); annotationResolver.setCallResolver(callResolver); @@ -263,6 +276,23 @@ public class InjectorForTopDownAnalyzerForJs { overrideResolver.setTrace(bindingTrace); + topDownAnalyzer.setBodyResolver(bodyResolver); + topDownAnalyzer.setDeclarationResolver(declarationResolver); + topDownAnalyzer.setModuleDescriptor(module); + topDownAnalyzer.setOverloadResolver(overloadResolver); + topDownAnalyzer.setOverrideResolver(overrideResolver); + topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider); + topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); + + typeHierarchyResolver.setDescriptorResolver(descriptorResolver); + typeHierarchyResolver.setImportsResolver(importsResolver); + typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); + typeHierarchyResolver.setTrace(bindingTrace); + + scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + scriptHeaderResolver.setTrace(bindingTrace); + } @PreDestroy