From ce45108fe97fa9ec78a30aabb558e7be30de667c Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 26 Nov 2014 14:54:23 +0300 Subject: [PATCH] LTDA: Add addition scope provider component for lazy resolve and create additional injector for REPL --- .../jet/cli/jvm/repl/ReplInterpreter.java | 28 +- .../di/InjectorForLazyResolveWithJava.java | 5 + .../jet/di/InjectorForReplWithJava.java | 412 ++++++++++++++++++ .../di/InjectorForTopDownAnalyzerForJvm.java | 5 + .../jet/di/InjectorForLazyResolve.java | 5 + .../InjectorForLazyTopDownAnalyzerBasic.java | 5 + .../jet/lang/resolve/lazy/ScopeProvider.java | 32 +- .../generators/injectors/GenerateInjectors.kt | 103 +++-- .../di/InjectorForTopDownAnalyzerForJs.java | 5 + 9 files changed, 529 insertions(+), 71 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java 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 4e41ae7480c..de391eb28a5 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 @@ -29,7 +29,7 @@ import com.intellij.psi.PsiFileFactory; import com.intellij.psi.impl.PsiFileFactoryImpl; import com.intellij.psi.search.ProjectScope; import com.intellij.testFramework.LightVirtualFile; -import kotlin.Function1; +import com.intellij.util.SmartList; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.OutputFile; @@ -46,7 +46,7 @@ import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.context.ContextPackage; import org.jetbrains.jet.context.GlobalContextImpl; -import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; +import org.jetbrains.jet.di.InjectorForReplWithJava; import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; @@ -56,6 +56,7 @@ import org.jetbrains.jet.lang.psi.JetScript; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo; import org.jetbrains.jet.lang.resolve.lazy.declarations.*; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -118,25 +119,27 @@ public class ReplInterpreter { scriptDeclarationFactory = new ScriptMutableDeclarationProviderFactory(); - InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm( + ScopeProvider.AdditionalFileScopeProvider scopeProvider = new ScopeProvider.AdditionalFileScopeProvider() { + @NotNull + @Override + public List scopes(@NotNull JetFile file) { + return lastLineScope != null ? new SmartList(lastLineScope) : Collections.emptyList(); + } + }; + + InjectorForReplWithJava injector = new InjectorForReplWithJava( project, - context, + topDownAnalysisParameters, trace, module, scriptDeclarationFactory, - ProjectScope.getAllScope(project) + ProjectScope.getAllScope(project), + scopeProvider ); this.topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters); this.topDownAnalyzer = injector.getLazyTopDownAnalyzer(); - this.topDownAnalyzer.getCodeAnalyzer().getScopeProvider().setAdditionalFileScopesProvider(new Function1() { - @Override - public JetScope invoke(JetFile file) { - return lastLineScope; - } - }); - module.initialize(new CompositePackageFragmentProvider( Arrays.asList( injector.getResolveSession().getPackageFragmentProvider(), @@ -317,6 +320,7 @@ public class ReplInterpreter { return LineResult.successful(rv, returnType != null && KotlinBuiltIns.getInstance().isUnit(returnType)); } catch (Throwable e) { + @SuppressWarnings("UseOfSystemOutOrSystemErr") PrintWriter writer = new PrintWriter(System.err); classLoader.dumpClasses(writer); writer.flush(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java index fb3ecc1f871..3b526f36663 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -62,6 +62,7 @@ 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.lazy.ScopeProvider.AdditionalFileScopeProvider; import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext; @@ -122,6 +123,7 @@ public class InjectorForLazyResolveWithJava { private final TaskPrioritizer taskPrioritizer; private final JetImportsFactory jetImportsFactory; private final ScopeProvider scopeProvider; + private final AdditionalFileScopeProvider additionalFileScopeProvider; private final ScriptBodyResolver scriptBodyResolver; private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; private final GlobalJavaResolverContext globalJavaResolverContext; @@ -188,6 +190,7 @@ public class InjectorForLazyResolveWithJava { this.taskPrioritizer = new TaskPrioritizer(storageManager); this.jetImportsFactory = new JetImportsFactory(); this.scopeProvider = new ScopeProvider(getResolveSession()); + this.additionalFileScopeProvider = new AdditionalFileScopeProvider(); this.scriptBodyResolver = new ScriptBodyResolver(); this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver); this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, virtualFileFinder, traceBasedErrorReporter); @@ -272,6 +275,8 @@ public class InjectorForLazyResolveWithJava { jetImportsFactory.setProject(project); + scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider); + scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); deserializedDescriptorResolver.setComponents(deserializationComponentsForJava); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java new file mode 100644 index 00000000000..b37a95e2160 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java @@ -0,0 +1,412 @@ +/* + * 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 com.intellij.psi.search.GlobalSearchScope; +import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.kotlin.DeserializationComponentsForJava; +import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; +import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl; +import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.LazyResolveBasedCache; +import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter; +import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker; +import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver; +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; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; +import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider; +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.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.jet.lang.resolve.TopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; +import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider; +import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext; +import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; +import org.jetbrains.jet.lang.resolve.kotlin.JavaClassDataFinder; +import org.jetbrains.jet.lang.resolve.kotlin.BinaryClassAnnotationAndConstantLoaderImpl; +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 InjectorForReplWithJava { + + private final Project project; + private final GlobalContext globalContext; + private final StorageManager storageManager; + private final BindingTrace bindingTrace; + private final ModuleDescriptorImpl module; + private final PlatformToKotlinClassMap platformToKotlinClassMap; + private final DeclarationProviderFactory declarationProviderFactory; + private final ResolveSession resolveSession; + private final GlobalSearchScope moduleContentScope; + private final LazyTopDownAnalyzer lazyTopDownAnalyzer; + private final JavaDescriptorResolver javaDescriptorResolver; + private final DeserializationComponentsForJava deserializationComponentsForJava; + private final VirtualFileFinder virtualFileFinder; + private final JavaClassFinderImpl javaClassFinder; + private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver; + private final LazyResolveBasedCache lazyResolveBasedCache; + private final TraceBasedErrorReporter traceBasedErrorReporter; + private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker; + private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver; + 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; + private final AdditionalCheckerProvider additionalCheckerProvider; + private final AdditionalFileScopeProvider additionalFileScopeProvider; + 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 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; + private final TopDownAnalyzer topDownAnalyzer; + private final TypeHierarchyResolver typeHierarchyResolver; + private final ScriptHeaderResolver scriptHeaderResolver; + private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; + private final GlobalJavaResolverContext globalJavaResolverContext; + private final DeserializedDescriptorResolver deserializedDescriptorResolver; + private final JavaClassDataFinder javaClassDataFinder; + private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader; + + public InjectorForReplWithJava( + @NotNull Project project, + @NotNull GlobalContext globalContext, + @NotNull BindingTrace bindingTrace, + @NotNull ModuleDescriptorImpl module, + @NotNull DeclarationProviderFactory declarationProviderFactory, + @NotNull GlobalSearchScope moduleContentScope, + @NotNull AdditionalFileScopeProvider additionalFileScopeProvider + ) { + this.project = project; + this.globalContext = globalContext; + this.storageManager = globalContext.getStorageManager(); + this.bindingTrace = bindingTrace; + this.module = module; + this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap(); + this.declarationProviderFactory = declarationProviderFactory; + this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace); + this.moduleContentScope = moduleContentScope; + this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); + this.javaClassFinder = new JavaClassFinderImpl(); + this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope); + this.traceBasedErrorReporter = new TraceBasedErrorReporter(); + this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(traceBasedErrorReporter); + this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver(); + this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver(); + this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker(); + this.lazyResolveBasedCache = new LazyResolveBasedCache(); + this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl(); + this.samConversionResolver = SamConversionResolverImpl.INSTANCE$; + this.javaSourceElementFactory = new JavaSourceElementFactoryImpl(); + this.singleModuleClassResolver = new SingleModuleClassResolver(); + this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver); + this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, module); + this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module); + 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$; + this.additionalFileScopeProvider = additionalFileScopeProvider; + 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(module); + this.callExpressionResolver = new CallExpressionResolver(); + this.descriptorResolver = new DescriptorResolver(); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, 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.topDownAnalyzer = new TopDownAnalyzer(); + this.typeHierarchyResolver = new TypeHierarchyResolver(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); + + 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(module); + this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); + this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); + this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer); + this.lazyTopDownAnalyzer.setTrace(bindingTrace); + + javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct); + javaClassFinder.setProject(project); + javaClassFinder.setScope(moduleContentScope); + + traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); + traceBasedExternalSignatureResolver.setProject(project); + traceBasedExternalSignatureResolver.setTrace(bindingTrace); + + lazyResolveBasedCache.setSession(resolveSession); + + traceBasedErrorReporter.setTrace(bindingTrace); + + psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); + psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver); + + singleModuleClassResolver.setResolver(javaDescriptorResolver); + + javaLazyAnalyzerPostConstruct.setCodeAnalyzer(resolveSession); + javaLazyAnalyzerPostConstruct.setProject(project); + javaLazyAnalyzerPostConstruct.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); + + scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider); + + 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(module); + importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); + importsResolver.setTrace(bindingTrace); + + overloadResolver.setTrace(bindingTrace); + + 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(); + + javaLazyAnalyzerPostConstruct.postCreate(); + + } + + @PreDestroy + public void destroy() { + } + + public ResolveSession getResolveSession() { + return this.resolveSession; + } + + public LazyTopDownAnalyzer getLazyTopDownAnalyzer() { + return this.lazyTopDownAnalyzer; + } + + public JavaDescriptorResolver getJavaDescriptorResolver() { + return this.javaDescriptorResolver; + } + + public DeserializationComponentsForJava getDeserializationComponentsForJava() { + return this.deserializationComponentsForJava; + } + +} 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 00f46233282..96962039968 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -65,6 +65,7 @@ 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.lazy.ScopeProvider.AdditionalFileScopeProvider; import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.jet.lang.resolve.BodyResolver; import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; @@ -139,6 +140,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final TaskPrioritizer taskPrioritizer; private final JetImportsFactory jetImportsFactory; private final ScopeProvider scopeProvider; + private final AdditionalFileScopeProvider additionalFileScopeProvider; private final ScriptBodyResolver scriptBodyResolver; private final BodyResolver bodyResolver; private final ControlFlowAnalyzer controlFlowAnalyzer; @@ -220,6 +222,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.taskPrioritizer = new TaskPrioritizer(storageManager); this.jetImportsFactory = new JetImportsFactory(); this.scopeProvider = new ScopeProvider(getResolveSession()); + this.additionalFileScopeProvider = new AdditionalFileScopeProvider(); this.scriptBodyResolver = new ScriptBodyResolver(); this.bodyResolver = new BodyResolver(); this.controlFlowAnalyzer = new ControlFlowAnalyzer(); @@ -324,6 +327,8 @@ public class InjectorForTopDownAnalyzerForJvm { jetImportsFactory.setProject(project); + scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider); + scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); bodyResolver.setAnnotationResolver(annotationResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 1b03fbac0a3..f6adadb8adf 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -48,6 +48,7 @@ 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.lazy.ScopeProvider.AdditionalFileScopeProvider; import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -88,6 +89,7 @@ public class InjectorForLazyResolve { private final TaskPrioritizer taskPrioritizer; private final JetImportsFactory jetImportsFactory; private final ScopeProvider scopeProvider; + private final AdditionalFileScopeProvider additionalFileScopeProvider; private final ScriptBodyResolver scriptBodyResolver; public InjectorForLazyResolve( @@ -130,6 +132,7 @@ public class InjectorForLazyResolve { this.taskPrioritizer = new TaskPrioritizer(storageManager); this.jetImportsFactory = new JetImportsFactory(); this.scopeProvider = new ScopeProvider(getResolveSession()); + this.additionalFileScopeProvider = new AdditionalFileScopeProvider(); this.scriptBodyResolver = new ScriptBodyResolver(); this.resolveSession.setAnnotationResolve(annotationResolver); @@ -192,6 +195,8 @@ public class InjectorForLazyResolve { jetImportsFactory.setProject(project); + scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider); + scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); } diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java index b8ed738a5a2..5f38d8eca16 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java @@ -49,6 +49,7 @@ 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.lazy.ScopeProvider.AdditionalFileScopeProvider; import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.jet.lang.resolve.BodyResolver; import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; @@ -103,6 +104,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { private final TaskPrioritizer taskPrioritizer; private final JetImportsFactory jetImportsFactory; private final ScopeProvider scopeProvider; + private final AdditionalFileScopeProvider additionalFileScopeProvider; private final ScriptBodyResolver scriptBodyResolver; private final BodyResolver bodyResolver; private final ControlFlowAnalyzer controlFlowAnalyzer; @@ -158,6 +160,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { this.taskPrioritizer = new TaskPrioritizer(storageManager); this.jetImportsFactory = new JetImportsFactory(); this.scopeProvider = new ScopeProvider(getResolveSession()); + this.additionalFileScopeProvider = new AdditionalFileScopeProvider(); this.scriptBodyResolver = new ScriptBodyResolver(); this.bodyResolver = new BodyResolver(); this.controlFlowAnalyzer = new ControlFlowAnalyzer(); @@ -242,6 +245,8 @@ public class InjectorForLazyTopDownAnalyzerBasic { jetImportsFactory.setProject(project); + scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider); + scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); bodyResolver.setAnnotationResolver(annotationResolver); 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 3e2ea2871e6..b49a52b8883 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 @@ -30,21 +30,36 @@ import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.scopes.ChainedScope; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.storage.LockBasedStorageManager; import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; import org.jetbrains.jet.storage.NotNullLazyValue; +import javax.inject.Inject; import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; import java.util.List; public class ScopeProvider { + public static class AdditionalFileScopeProvider { + @NotNull + public List scopes(@NotNull JetFile file) { + return Collections.emptyList(); + } + } + private final ResolveSession resolveSession; private final MemoizedFunctionToNotNull explicitImportScopes; private final NotNullLazyValue defaultImportsScope; - private Function1 additionalScopesProvider; + + @SuppressWarnings("ConstantConditions") @NotNull + private AdditionalFileScopeProvider additionalFileScopeProvider = null; + + @Inject + public void setAdditionalFileScopesProvider(@NotNull AdditionalFileScopeProvider additionalFileScopeProvider) { + this.additionalFileScopeProvider = additionalFileScopeProvider; + } public ScopeProvider(@NotNull ResolveSession resolveSession) { this.resolveSession = resolveSession; @@ -85,23 +100,12 @@ public class ScopeProvider { list.add(getFilePackageDescriptor(file).getMemberScope()); list.add(JetModuleUtil.getSubpackagesOfRootScope(resolveSession.getModuleDescriptor())); list.add(explicitImportScopes.invoke(file)); - - if (additionalScopesProvider != null) { - JetScope additionalScope = additionalScopesProvider.invoke(file); - if (additionalScope != null) { - list.add(additionalScope); - } - } - + list.addAll(additionalFileScopeProvider.scopes(file)); list.add(defaultImportsScope.invoke()); return list.toArray(new JetScope[list.size()]); } - public void setAdditionalFileScopesProvider(@NotNull Function1 scopeProvider) { - this.additionalScopesProvider = scopeProvider; - } - @NotNull public LazyImportScope getExplicitImportsScopeForFile(@NotNull JetFile file) { return explicitImportScopes.invoke(file); diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 461282867ec..9997129a3ae 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -47,6 +47,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaFlexibleTypeCapabilitiesProvider import org.jetbrains.jet.context.LazyResolveToken import org.jetbrains.jet.lang.resolve.java.JavaLazyAnalyzerPostConstruct import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolverPostConstruct +import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider // NOTE: After making changes, you need to re-generate the injectors. // To do that, you can run main in this file. @@ -74,19 +75,10 @@ public fun createInjectorGenerators(): List = generatorForTests(), generatorForLazyResolve(), generatorForBodyResolve(), - generatorForLazyBodyResolve() + generatorForLazyBodyResolve(), + generatorForReplWithJava() ) -private fun DependencyInjectorGenerator.commonForResolveSessionBased() { - parameter(javaClass()) - parameter(javaClass(), useAsContext = true) - parameter(javaClass()) - parameter(javaClass(), name = "module", useAsContext = true) - parameter(javaClass()) - - publicField(javaClass()) -} - private fun generatorForTopDownAnalyzerBasic() = generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic") { parameter(javaClass()) @@ -145,40 +137,7 @@ private fun generatorForTopDownAnalyzerForJs() = private fun generatorForTopDownAnalyzerForJvm() = generator("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJvm") { - commonForResolveSessionBased() - - parameter(javaClass(), name = "moduleContentScope") - - publicFields( - javaClass(), - javaClass(), - javaClass() - ) - - field(javaClass(), - init = GivenExpression(javaClass().getName() - + ".SERVICE.getInstance(project).create(moduleContentScope)") - ) - fields( - javaClass(), - javaClass(), - javaClass(), - javaClass(), - javaClass(), - javaClass(), - javaClass(), - javaClass(), - javaClass(), - javaClass(), - javaClass(), - javaClass(), - javaClass() - ) - - field(javaClass(), - init = GivenExpression(javaClass().getName() + ".INSTANCE$")) - - field(javaClass(), init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) + commonForJavaTopDownAnalyzer() } private fun generatorForJavaDescriptorResolver() = @@ -250,6 +209,12 @@ private fun generatorForLazyResolveWithJava() = init = GivenExpression(javaClass().getName() + ".INSTANCE$")) } +private fun generatorForReplWithJava() = + generator("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForReplWithJava") { + commonForJavaTopDownAnalyzer() + parameter(javaClass()) + } + private fun generatorForMacro() = generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForMacros") { parameter(javaClass()) @@ -311,6 +276,54 @@ private fun generatorForLazyResolve() = field(javaClass()) } +private fun DependencyInjectorGenerator.commonForResolveSessionBased() { + parameter(javaClass()) + parameter(javaClass(), useAsContext = true) + parameter(javaClass()) + parameter(javaClass(), name = "module", useAsContext = true) + parameter(javaClass()) + + publicField(javaClass()) +} + +private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() { + commonForResolveSessionBased() + + parameter(javaClass(), name = "moduleContentScope") + + publicFields( + javaClass(), + javaClass(), + javaClass() + ) + + field(javaClass(), + init = GivenExpression(javaClass().getName() + + ".SERVICE.getInstance(project).create(moduleContentScope)") + ) + fields( + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass() + ) + + field(javaClass(), + init = GivenExpression(javaClass().getName() + ".INSTANCE$")) + + field(javaClass(), init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) +} + + private fun generator( targetSourceRoot: String, injectorPackageName: String, 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 9ed11a38f88..ddc609b647b 100644 --- a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -50,6 +50,7 @@ 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.lazy.ScopeProvider.AdditionalFileScopeProvider; import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.jet.lang.resolve.BodyResolver; import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; @@ -104,6 +105,7 @@ public class InjectorForTopDownAnalyzerForJs { private final TaskPrioritizer taskPrioritizer; private final JetImportsFactory jetImportsFactory; private final ScopeProvider scopeProvider; + private final AdditionalFileScopeProvider additionalFileScopeProvider; private final ScriptBodyResolver scriptBodyResolver; private final BodyResolver bodyResolver; private final ControlFlowAnalyzer controlFlowAnalyzer; @@ -159,6 +161,7 @@ public class InjectorForTopDownAnalyzerForJs { this.taskPrioritizer = new TaskPrioritizer(storageManager); this.jetImportsFactory = new JetImportsFactory(); this.scopeProvider = new ScopeProvider(getResolveSession()); + this.additionalFileScopeProvider = new AdditionalFileScopeProvider(); this.scriptBodyResolver = new ScriptBodyResolver(); this.bodyResolver = new BodyResolver(); this.controlFlowAnalyzer = new ControlFlowAnalyzer(); @@ -242,6 +245,8 @@ public class InjectorForTopDownAnalyzerForJs { jetImportsFactory.setProject(project); + scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider); + scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); bodyResolver.setAnnotationResolver(annotationResolver);