From 994c8886bcb26b0cb05b0ddb770a77c11535e4b0 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 25 Sep 2014 21:45:22 +0400 Subject: [PATCH] LTDA: Initialize built-ins reference resolver with lazy tda --- .../InjectorForLazyTopDownAnalyzerBasic.java | 280 ++++++++++++++++++ .../generators/injectors/GenerateInjectors.kt | 18 ++ .../references/BuiltInsReferenceResolver.java | 14 +- 3 files changed, 307 insertions(+), 5 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java new file mode 100644 index 00000000000..72b01b79a85 --- /dev/null +++ b/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; + } + +} diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 34bcbbbb515..1ddbe136b75 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -63,6 +63,7 @@ public fun main(args: Array) { public fun createInjectorGenerators(): List = listOf( generatorForTopDownAnalyzerBasic(), + generatorForLazyTopDownAnalyzerBasic(), generatorForTopDownAnalyzerForJvm(), generatorForJavaDescriptorResolver(), generatorForLazyResolveWithJava(), @@ -93,6 +94,23 @@ private fun generatorForTopDownAnalyzerBasic() = parameter(javaClass()) } +private fun generatorForLazyTopDownAnalyzerBasic() = + generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyTopDownAnalyzerBasic") { + parameter(javaClass()) + parameter(javaClass(), useAsContext = true) + parameter(javaClass()) + parameter(javaClass(), useAsContext = true) + parameter(javaClass()) + + publicFields( + javaClass(), + javaClass() + ) + + field(javaClass(), + init = GivenExpression(javaClass().getCanonicalName() + ".INSTANCE$")) + } + private fun generatorForLazyBodyResolve() = generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyBodyResolve") { parameter(javaClass()) diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java index 477f1c30b32..4713b659e4a 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java +++ b/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(); - analyzer.analyzeFiles(topDownAnalysisParameters, jetBuiltInsFiles); + FileBasedDeclarationProviderFactory declarationFactory = + new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), jetBuiltInsFiles); + + LazyTopDownAnalyzer analyzer = new InjectorForLazyTopDownAnalyzerBasic( + myProject, topDownAnalysisParameters, trace, module, declarationFactory).getLazyTopDownAnalyzer(); + + analyzer.analyzeFiles(topDownAnalysisParameters, jetBuiltInsFiles, Collections.emptyList()); List fragments = module.getPackageFragmentProvider().getPackageFragments(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME);