From 53b699d74533a31985af4515e46a49e61b7d623d Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 19 Sep 2014 14:39:30 +0400 Subject: [PATCH] LTDA: Injector with Lazy TDA for JS target --- .../generators/injectors/GenerateInjectors.kt | 38 +++--- .../di/InjectorForTopDownAnalyzerForJs.java | 127 +++++++++--------- .../analyze/TopDownAnalyzerFacadeForJS.java | 17 ++- 3 files changed, 97 insertions(+), 85 deletions(-) diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 1ddbe136b75..481fee8293a 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -75,22 +75,19 @@ public fun createInjectorGenerators(): List = generatorForLazyBodyResolve() ) -private fun DependencyInjectorGenerator.commonForTopDownAnalyzer() { - parameter(javaClass()) - parameter(javaClass(), useAsContext = true) - parameter(javaClass()) - publicParameter(javaClass(), useAsContext = true) - - publicFields( - javaClass() - ) - - field(javaClass()) -} - private fun generatorForTopDownAnalyzerBasic() = generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic") { - commonForTopDownAnalyzer() + parameter(javaClass()) + parameter(javaClass(), useAsContext = true) + parameter(javaClass()) + publicParameter(javaClass(), useAsContext = true) + + publicFields( + javaClass() + ) + + field(javaClass()) + parameter(javaClass()) } @@ -128,7 +125,18 @@ private fun generatorForLazyBodyResolve() = private fun generatorForTopDownAnalyzerForJs() = generator("js/js.frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs") { - commonForTopDownAnalyzer() + parameter(javaClass()) + parameter(javaClass(), useAsContext = true) + parameter(javaClass()) + parameter(javaClass(), name = "module", useAsContext = true) + parameter(javaClass()) + + publicFields( + javaClass(), + javaClass() + ) + + field(javaClass()) field(javaClass(), init = GivenExpression(javaClass().getCanonicalName() + ".INSTANCE$")) 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 ef5939dc3a8..bc786022440 100644 --- a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -20,12 +20,12 @@ 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.ModuleDescriptor; +import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; -import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; -import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; +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.BodyResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; @@ -47,18 +47,18 @@ 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.ScriptBodyResolver; import org.jetbrains.jet.lang.resolve.DeclarationResolver; 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.TypeHierarchyResolver; -import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -70,12 +70,12 @@ public class InjectorForTopDownAnalyzerForJs { private final GlobalContext globalContext; private final StorageManager storageManager; private final BindingTrace bindingTrace; - private final ModuleDescriptor moduleDescriptor; + private final ModuleDescriptorImpl module; private final PlatformToKotlinClassMap platformToKotlinClassMap; - private final TopDownAnalyzer topDownAnalyzer; - private final MutablePackageFragmentProvider mutablePackageFragmentProvider; + private final DeclarationProviderFactory declarationProviderFactory; + private final ResolveSession resolveSession; + private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final AdditionalCheckerProvider additionalCheckerProvider; - private final BodyResolver bodyResolver; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -97,35 +97,36 @@ public class InjectorForTopDownAnalyzerForJs { 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 ScriptBodyResolver scriptBodyResolver; private final DeclarationResolver declarationResolver; private final ImportsResolver importsResolver; - private final JetImportsFactory jetImportsFactory; private final OverloadResolver overloadResolver; private final OverrideResolver overrideResolver; - private final TypeHierarchyResolver typeHierarchyResolver; - private final ScriptHeaderResolver scriptHeaderResolver; public InjectorForTopDownAnalyzerForJs( @NotNull Project project, @NotNull GlobalContext globalContext, @NotNull BindingTrace bindingTrace, - @NotNull ModuleDescriptor moduleDescriptor + @NotNull ModuleDescriptorImpl module, + @NotNull DeclarationProviderFactory declarationProviderFactory ) { this.project = project; this.globalContext = globalContext; this.storageManager = globalContext.getStorageManager(); this.bindingTrace = bindingTrace; - this.moduleDescriptor = moduleDescriptor; - this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); - this.topDownAnalyzer = new TopDownAnalyzer(); - this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor()); + this.module = module; + this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap(); + this.declarationProviderFactory = declarationProviderFactory; + this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace); + this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty.INSTANCE$; - this.bodyResolver = new BodyResolver(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); @@ -134,52 +135,47 @@ public class InjectorForTopDownAnalyzerForJs { this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); - this.reflectionTypes = new ReflectionTypes(getModuleDescriptor()); + this.reflectionTypes = new ReflectionTypes(module); 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, getModuleDescriptor(), flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, 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.scriptBodyResolver = new ScriptBodyResolver(); this.declarationResolver = new DeclarationResolver(); this.importsResolver = new ImportsResolver(); - this.jetImportsFactory = new JetImportsFactory(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); - 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); + 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); - 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); + this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver); + this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver); + this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession); + this.lazyTopDownAnalyzer.setModuleDescriptor(module); + this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); + this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); + this.lazyTopDownAnalyzer.setTrace(bindingTrace); annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); @@ -231,6 +227,20 @@ public class InjectorForTopDownAnalyzerForJs { 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); @@ -239,45 +249,32 @@ public class InjectorForTopDownAnalyzerForJs { functionAnalyzerExtension.setTrace(bindingTrace); - scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); - declarationResolver.setAnnotationResolver(annotationResolver); declarationResolver.setDescriptorResolver(descriptorResolver); declarationResolver.setImportsResolver(importsResolver); declarationResolver.setTrace(bindingTrace); importsResolver.setImportsFactory(jetImportsFactory); - importsResolver.setModuleDescriptor(moduleDescriptor); + importsResolver.setModuleDescriptor(module); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); - jetImportsFactory.setProject(project); - overloadResolver.setTrace(bindingTrace); overrideResolver.setTrace(bindingTrace); - typeHierarchyResolver.setDescriptorResolver(descriptorResolver); - typeHierarchyResolver.setImportsResolver(importsResolver); - typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); - typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); - typeHierarchyResolver.setTrace(bindingTrace); - - scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); - scriptHeaderResolver.setTrace(bindingTrace); - } @PreDestroy public void destroy() { } - public ModuleDescriptor getModuleDescriptor() { - return this.moduleDescriptor; + public ResolveSession getResolveSession() { + return this.resolveSession; } - public TopDownAnalyzer getTopDownAnalyzer() { - return this.topDownAnalyzer; + public LazyTopDownAnalyzer getLazyTopDownAnalyzer() { + return this.lazyTopDownAnalyzer; } } diff --git a/js/js.frontend/src/org/jetbrains/k2js/analyze/TopDownAnalyzerFacadeForJS.java b/js/js.frontend/src/org/jetbrains/k2js/analyze/TopDownAnalyzerFacadeForJS.java index f53f49bbfb3..0d9e8054655 100644 --- a/js/js.frontend/src/org/jetbrains/k2js/analyze/TopDownAnalyzerFacadeForJS.java +++ b/js/js.frontend/src/org/jetbrains/k2js/analyze/TopDownAnalyzerFacadeForJS.java @@ -29,14 +29,17 @@ import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; 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.types.lang.KotlinBuiltIns; import org.jetbrains.k2js.config.Config; import java.util.Collection; +import java.util.Collections; import java.util.List; public final class TopDownAnalyzerFacadeForJS { @@ -96,12 +99,16 @@ public final class TopDownAnalyzerFacadeForJS { TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create( globalContext.getStorageManager(), globalContext.getExceptionTracker(), completely, false, false); - InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(project, topDownAnalysisParameters, trace, module); + Collection allFiles = config.getLibraryModule() != null ? + files : + Config.withJsLibAdded(files, config); + + InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( + project, topDownAnalysisParameters, trace, module, + new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), allFiles)); try { - Collection allFiles = config.getLibraryModule() != null ? - files : - Config.withJsLibAdded(files, config); - injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, allFiles); + injector.getLazyTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, allFiles, + Collections.emptyList()); return AnalysisResult.success(trace.getBindingContext(), module); } finally {