LTDA: Initialize built-ins reference resolver with lazy tda

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java

@@ -0,0 +1,280 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.di;
+
+import com.intellij.openapi.project.Project;
+import org.jetbrains.jet.context.GlobalContext;
+import org.jetbrains.jet.storage.StorageManager;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
+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.AdditionalCheckerProvider;
+import org.jetbrains.jet.lang.resolve.AnnotationResolver;
+import org.jetbrains.jet.lang.resolve.calls.CallResolver;
+import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents;
+import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
+import org.jetbrains.jet.lang.types.expressions.ForLoopConventionsChecker;
+import org.jetbrains.jet.lang.reflect.ReflectionTypes;
+import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
+import org.jetbrains.jet.lang.resolve.DescriptorResolver;
+import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver;
+import org.jetbrains.jet.lang.resolve.TypeResolver;
+import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
+import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
+import org.jetbrains.jet.context.LazinessToken;
+import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
+import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider;
+import org.jetbrains.jet.lang.resolve.calls.CallCompleter;
+import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
+import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer;
+import org.jetbrains.jet.lang.psi.JetImportsFactory;
+import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
+import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
+import org.jetbrains.jet.lang.resolve.BodyResolver;
+import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer;
+import org.jetbrains.jet.lang.resolve.DeclarationsChecker;
+import org.jetbrains.jet.lang.resolve.ModifiersChecker;
+import org.jetbrains.jet.lang.resolve.FunctionAnalyzerExtension;
+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.annotations.NotNull;
+import javax.annotation.PreDestroy;
+
+/* This file is generated by org.jetbrains.jet.generators.injectors.InjectorsPackage. DO NOT EDIT! */
+@SuppressWarnings("all")
+public class InjectorForLazyTopDownAnalyzerBasic {
+
+    private final Project project;
+    private final GlobalContext globalContext;
+    private final StorageManager storageManager;
+    private final BindingTrace bindingTrace;
+    private final ModuleDescriptorImpl moduleDescriptor;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
+    private final DeclarationProviderFactory declarationProviderFactory;
+    private final ResolveSession resolveSession;
+    private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
+    private final AdditionalCheckerProvider additionalCheckerProvider;
+    private final AnnotationResolver annotationResolver;
+    private final CallResolver callResolver;
+    private final ArgumentTypeResolver argumentTypeResolver;
+    private final ExpressionTypingServices expressionTypingServices;
+    private final ExpressionTypingComponents expressionTypingComponents;
+    private final ControlStructureTypingUtils controlStructureTypingUtils;
+    private final ExpressionTypingUtils expressionTypingUtils;
+    private final ForLoopConventionsChecker forLoopConventionsChecker;
+    private final ReflectionTypes reflectionTypes;
+    private final CallExpressionResolver callExpressionResolver;
+    private final DescriptorResolver descriptorResolver;
+    private final DelegatedPropertyResolver delegatedPropertyResolver;
+    private final TypeResolver typeResolver;
+    private final QualifiedExpressionResolver qualifiedExpressionResolver;
+    private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
+    private final LazinessToken lazinessToken;
+    private final CallResolverExtensionProvider callResolverExtensionProvider;
+    private final PartialBodyResolveProvider partialBodyResolveProvider;
+    private final CallCompleter callCompleter;
+    private final CandidateResolver candidateResolver;
+    private final TaskPrioritizer taskPrioritizer;
+    private final JetImportsFactory jetImportsFactory;
+    private final ScopeProvider scopeProvider;
+    private final ScriptBodyResolver scriptBodyResolver;
+    private final BodyResolver bodyResolver;
+    private final ControlFlowAnalyzer controlFlowAnalyzer;
+    private final DeclarationsChecker declarationsChecker;
+    private final ModifiersChecker modifiersChecker;
+    private final FunctionAnalyzerExtension functionAnalyzerExtension;
+    private final DeclarationResolver declarationResolver;
+    private final ImportsResolver importsResolver;
+    private final OverloadResolver overloadResolver;
+    private final OverrideResolver overrideResolver;
+
+    public InjectorForLazyTopDownAnalyzerBasic(
+        @NotNull Project project,
+        @NotNull GlobalContext globalContext,
+        @NotNull BindingTrace bindingTrace,
+        @NotNull ModuleDescriptorImpl moduleDescriptor,
+        @NotNull DeclarationProviderFactory declarationProviderFactory
+    ) {
+        this.project = project;
+        this.globalContext = globalContext;
+        this.storageManager = globalContext.getStorageManager();
+        this.bindingTrace = bindingTrace;
+        this.moduleDescriptor = moduleDescriptor;
+        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
+        this.declarationProviderFactory = declarationProviderFactory;
+        this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
+        this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
+        this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty.INSTANCE$;
+        this.annotationResolver = new AnnotationResolver();
+        this.callResolver = new CallResolver();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
+        this.expressionTypingComponents = new ExpressionTypingComponents();
+        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
+        this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
+        this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver);
+        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
+        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
+        this.callExpressionResolver = new CallExpressionResolver();
+        this.descriptorResolver = new DescriptorResolver();
+        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
+        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
+        this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
+        this.lazinessToken = new LazinessToken();
+        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken);
+        this.callResolverExtensionProvider = new CallResolverExtensionProvider();
+        this.partialBodyResolveProvider = new PartialBodyResolveProvider();
+        this.candidateResolver = new CandidateResolver();
+        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
+        this.taskPrioritizer = new TaskPrioritizer(storageManager);
+        this.jetImportsFactory = new JetImportsFactory();
+        this.scopeProvider = new ScopeProvider(getResolveSession());
+        this.scriptBodyResolver = new ScriptBodyResolver();
+        this.bodyResolver = new BodyResolver();
+        this.controlFlowAnalyzer = new ControlFlowAnalyzer();
+        this.declarationsChecker = new DeclarationsChecker();
+        this.modifiersChecker = new ModifiersChecker(bindingTrace, additionalCheckerProvider);
+        this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
+        this.declarationResolver = new DeclarationResolver();
+        this.importsResolver = new ImportsResolver();
+        this.overloadResolver = new OverloadResolver();
+        this.overrideResolver = new OverrideResolver();
+
+        this.resolveSession.setAnnotationResolve(annotationResolver);
+        this.resolveSession.setDescriptorResolver(descriptorResolver);
+        this.resolveSession.setJetImportFactory(jetImportsFactory);
+        this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
+        this.resolveSession.setScopeProvider(scopeProvider);
+        this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
+        this.resolveSession.setTypeResolver(typeResolver);
+
+        this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
+        this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
+        this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession);
+        this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
+        this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
+        this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.lazyTopDownAnalyzer.setTrace(bindingTrace);
+
+        annotationResolver.setCallResolver(callResolver);
+        annotationResolver.setStorageManager(storageManager);
+        annotationResolver.setTypeResolver(typeResolver);
+
+        callResolver.setArgumentTypeResolver(argumentTypeResolver);
+        callResolver.setCallCompleter(callCompleter);
+        callResolver.setCandidateResolver(candidateResolver);
+        callResolver.setExpressionTypingServices(expressionTypingServices);
+        callResolver.setTaskPrioritizer(taskPrioritizer);
+        callResolver.setTypeResolver(typeResolver);
+
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setTypeResolver(typeResolver);
+
+        expressionTypingServices.setAnnotationResolver(annotationResolver);
+        expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
+        expressionTypingServices.setCallResolver(callResolver);
+        expressionTypingServices.setDescriptorResolver(descriptorResolver);
+        expressionTypingServices.setExtensionProvider(callResolverExtensionProvider);
+        expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
+        expressionTypingServices.setProject(project);
+        expressionTypingServices.setTypeResolver(typeResolver);
+
+        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
+        expressionTypingComponents.setCallResolver(callResolver);
+        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
+        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
+        expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
+        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
+        expressionTypingComponents.setGlobalContext(globalContext);
+        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
+        expressionTypingComponents.setReflectionTypes(reflectionTypes);
+
+        forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
+        forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
+        forLoopConventionsChecker.setProject(project);
+
+        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
+
+        descriptorResolver.setAnnotationResolver(annotationResolver);
+        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
+        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        descriptorResolver.setStorageManager(storageManager);
+        descriptorResolver.setTypeResolver(typeResolver);
+
+        delegatedPropertyResolver.setCallResolver(callResolver);
+        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
+
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
+
+        jetImportsFactory.setProject(project);
+
+        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
+
+        bodyResolver.setAnnotationResolver(annotationResolver);
+        bodyResolver.setCallResolver(callResolver);
+        bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
+        bodyResolver.setDeclarationsChecker(declarationsChecker);
+        bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
+        bodyResolver.setExpressionTypingServices(expressionTypingServices);
+        bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
+        bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
+        bodyResolver.setTrace(bindingTrace);
+
+        controlFlowAnalyzer.setTrace(bindingTrace);
+
+        declarationsChecker.setDescriptorResolver(descriptorResolver);
+        declarationsChecker.setModifiersChecker(modifiersChecker);
+        declarationsChecker.setTrace(bindingTrace);
+
+        functionAnalyzerExtension.setTrace(bindingTrace);
+
+        declarationResolver.setAnnotationResolver(annotationResolver);
+        declarationResolver.setDescriptorResolver(descriptorResolver);
+        declarationResolver.setImportsResolver(importsResolver);
+        declarationResolver.setTrace(bindingTrace);
+
+        importsResolver.setImportsFactory(jetImportsFactory);
+        importsResolver.setModuleDescriptor(moduleDescriptor);
+        importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
+        importsResolver.setTrace(bindingTrace);
+
+        overloadResolver.setTrace(bindingTrace);
+
+        overrideResolver.setTrace(bindingTrace);
+
+    }
+
+    @PreDestroy
+    public void destroy() {
+    }
+
+    public ResolveSession getResolveSession() {
+        return this.resolveSession;
+    }
+
+    public LazyTopDownAnalyzer getLazyTopDownAnalyzer() {
+        return this.lazyTopDownAnalyzer;
+    }
+
+}

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt

@@ -63,6 +63,7 @@ public fun main(args: Array<String>) {
 public fun createInjectorGenerators(): List<DependencyInjectorGenerator> =
         listOf(
                 generatorForTopDownAnalyzerBasic(),
+                generatorForLazyTopDownAnalyzerBasic(),
                 generatorForTopDownAnalyzerForJvm(),
                 generatorForJavaDescriptorResolver(),
                 generatorForLazyResolveWithJava(),
@@ -93,6 +94,23 @@ private fun generatorForTopDownAnalyzerBasic() =
             parameter(javaClass<AdditionalCheckerProvider>())
         }
 
+private fun generatorForLazyTopDownAnalyzerBasic() =
+        generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyTopDownAnalyzerBasic") {
+            parameter(javaClass<Project>())
+            parameter(javaClass<GlobalContext>(), useAsContext = true)
+            parameter(javaClass<BindingTrace>())
+            parameter(javaClass<ModuleDescriptorImpl>(), useAsContext = true)
+            parameter(javaClass<DeclarationProviderFactory>())
+
+            publicFields(
+                    javaClass<ResolveSession>(),
+                    javaClass<LazyTopDownAnalyzer>()
+            )
+
+            field(javaClass<AdditionalCheckerProvider>(),
+                  init = GivenExpression(javaClass<AdditionalCheckerProvider.Empty>().getCanonicalName() + ".INSTANCE$"))
+        }
+
 private fun generatorForLazyBodyResolve() =
         generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyBodyResolve") {
             parameter(javaClass<Project>())

idea/idea-analysis/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java

@@ -39,13 +39,14 @@ import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.jet.asJava.LightClassUtil;
 import org.jetbrains.jet.context.ContextPackage;
 import org.jetbrains.jet.context.GlobalContextImpl;
-import org.jetbrains.jet.di.InjectorForTopDownAnalyzerBasic;
+import org.jetbrains.jet.di.InjectorForLazyTopDownAnalyzerBasic;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -106,11 +107,14 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
                 module.addDependencyOnModule(module);
                 module.seal();
                 BindingTraceContext trace = new BindingTraceContext();
-                InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
-                        myProject, topDownAnalysisParameters, trace, module, AdditionalCheckerProvider.Empty.INSTANCE$);
 
-                TopDownAnalyzer analyzer = injector.getTopDownAnalyzer();
+                FileBasedDeclarationProviderFactory declarationFactory =
-                analyzer.analyzeFiles(topDownAnalysisParameters, jetBuiltInsFiles);
+                        new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), jetBuiltInsFiles);
+
+                LazyTopDownAnalyzer analyzer = new InjectorForLazyTopDownAnalyzerBasic(
+                        myProject, topDownAnalysisParameters, trace, module, declarationFactory).getLazyTopDownAnalyzer();
+
+                analyzer.analyzeFiles(topDownAnalysisParameters, jetBuiltInsFiles, Collections.<PackageFragmentProvider>emptyList());
 
                 List<PackageFragmentDescriptor> fragments =
                         module.getPackageFragmentProvider().getPackageFragments(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME);