From bc17c7b4f30abeeca9f86ec39279229d0334197c Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Mon, 26 Mar 2012 17:42:04 +0400 Subject: [PATCH] injector to analyze js --- .../di/InjectorForTopDownAnalyzerForJvm.java | 1 - .../di/InjectorForTopDownAnalyzerBasic.java | 1 - .../jet/lang/resolve/AnalyzingUtils.java | 23 -- .../jet/lang/resolve/TopDownAnalyzer.java | 55 +---- .../jet/di/AllInjectorsGenerator.java | 8 + .../di/InjectorForTopDownAnalyzerForJs.java | 214 ++++++++++++++++++ .../k2js/analyze/AnalyzerFacadeForJS.java | 40 ++-- 7 files changed, 258 insertions(+), 84 deletions(-) create mode 100644 js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java 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 fa4b996fde1..b51433013f8 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -99,7 +99,6 @@ public class InjectorForTopDownAnalyzerForJvm { JavaTypeTransformer javaTypeTransformer = new JavaTypeTransformer(); this.topDownAnalyzer.setBodyResolver(bodyResolver); - this.topDownAnalyzer.setConfiguration(javaBridgeConfiguration); this.topDownAnalyzer.setContext(topDownAnalysisContext); this.topDownAnalyzer.setControlFlowAnalyzer(controlFlowAnalyzer); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 6f14e78f693..250961def32 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -93,7 +93,6 @@ public class InjectorForTopDownAnalyzerBasic { TypeHierarchyResolver typeHierarchyResolver = new TypeHierarchyResolver(); this.topDownAnalyzer.setBodyResolver(bodyResolver); - this.topDownAnalyzer.setConfiguration(moduleConfiguration); this.topDownAnalyzer.setContext(topDownAnalysisContext); this.topDownAnalyzer.setControlFlowAnalyzer(controlFlowAnalyzer); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java index 15de36d5efd..f2c17c3576b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java @@ -76,27 +76,4 @@ public class AnalyzingUtils { } // -------------------------------------------------------------------------------------------------------------------------- - - public static BindingContext analyzeFiles( - @NotNull Project project, - @NotNull ModuleConfiguration configuration, - @NotNull Collection files, - @NotNull Predicate filesToAnalyzeCompletely, - @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) { - BindingTraceContext bindingTraceContext = new BindingTraceContext(); - analyzeFilesWithGivenTrace(project, configuration, files, filesToAnalyzeCompletely, flowDataTraceFactory, bindingTraceContext); - return bindingTraceContext.getBindingContext(); - } - - public static void analyzeFilesWithGivenTrace( - @NotNull Project project, - @NotNull final ModuleConfiguration configuration, - @NotNull Collection files, - @NotNull Predicate filesToAnalyzeCompletely, - @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory, - @NotNull BindingTraceContext bindingTraceContext) { - - TopDownAnalyzer.doAnalyzeFilesWithGivenTrace(project, configuration, files, filesToAnalyzeCompletely, flowDataTraceFactory, bindingTraceContext); - } - } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index fb7fc0dd049..6ad9fd96e4b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.lang.resolve; -import com.google.common.base.Predicate; import com.google.common.base.Predicates; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; @@ -62,8 +61,6 @@ public class TopDownAnalyzer { @NotNull private BindingTrace trace; @NotNull - private ModuleConfiguration configuration; - @NotNull private ModuleDescriptor moduleDescriptor; @NotNull private NamespaceFactoryImpl namespaceFactory; @@ -112,11 +109,6 @@ public class TopDownAnalyzer { this.context = context; } - @Inject - public void setConfiguration(@NotNull ModuleConfiguration configuration) { - this.configuration = configuration; - } - @Inject public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) { this.moduleDescriptor = moduleDescriptor; @@ -143,29 +135,6 @@ public class TopDownAnalyzer { } - - - public static void process( - @NotNull Project project, - @NotNull BindingTrace trace, - @NotNull JetScope outerScope, - @NotNull ModuleDescriptor moduleDescriptor, - @NotNull NamespaceLikeBuilder owner, - @NotNull Collection declarations, - @NotNull Predicate analyzeCompletely, - @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory, - @NotNull ModuleConfiguration configuration, - boolean declaredLocally) { - - TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(analyzeCompletely, false, declaredLocally); - - InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( - project, topDownAnalysisParameters, new ObservableBindingTrace(trace), moduleDescriptor, flowDataTraceFactory, configuration); - - injector.getTopDownAnalyzer().doProcess(outerScope, owner, declarations); - - } - public void doProcess( JetScope outerScope, NamespaceLikeBuilder owner, @@ -242,7 +211,14 @@ public class TopDownAnalyzer { ModuleDescriptor moduleDescriptor = new ModuleDescriptor(""); - process(project, trace, outerScope, moduleDescriptor, new NamespaceLikeBuilder() { + TopDownAnalysisParameters topDownAnalysisParameters = + new TopDownAnalysisParameters(Predicates.equalTo(object.getContainingFile()), false, true); + + InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( + project, topDownAnalysisParameters, new ObservableBindingTrace(trace), moduleDescriptor, + JetControlFlowDataTraceFactory.EMPTY, ModuleConfiguration.EMPTY); + + injector.getTopDownAnalyzer().doProcess(outerScope, new NamespaceLikeBuilder() { @NotNull @Override @@ -274,23 +250,10 @@ public class TopDownAnalyzer { public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptorLite classObjectDescriptor) { return ClassObjectStatus.NOT_ALLOWED; } - }, Collections.singletonList(object), Predicates.equalTo(object.getContainingFile()), JetControlFlowDataTraceFactory.EMPTY, ModuleConfiguration.EMPTY, true); + }, Collections.singletonList(object)); } - public static void doAnalyzeFilesWithGivenTrace(Project project, final ModuleConfiguration configuration, Collection files, Predicate filesToAnalyzeCompletely, JetControlFlowDataTraceFactory flowDataTraceFactory, BindingTraceContext bindingTraceContext) { - final ModuleDescriptor owner = new ModuleDescriptor(""); - - TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - filesToAnalyzeCompletely, false, false); - - InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( - project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, flowDataTraceFactory, configuration); - - - injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(files); - } - public void doAnalyzeFilesWithGivenTrance2(Collection files) { final WritableScope scope = new WritableScopeImpl( JetScope.EMPTY, moduleDescriptor, diff --git a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java index 56c0f619ccf..f82f8addb02 100644 --- a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java +++ b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java @@ -40,6 +40,7 @@ public class AllInjectorsGenerator { public static void main(String[] args) throws IOException { generateInjectorForTopDownAnalyzerBasic(); generateInjectorForTopDownAnalyzerForJvm(); + generateInjectorForTopDownAnalyzerForJs(); generateMacroInjector(); generateTestInjector(); generateInjectorForJavaSemanticServices(); @@ -52,6 +53,13 @@ public class AllInjectorsGenerator { generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic"); } + private static void generateInjectorForTopDownAnalyzerForJs() throws IOException { + DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false); + generateInjectorForTopDownAnalyzerCommon(generator); + generator.addParameter(ModuleConfiguration.class); + generator.generate("js/js.translator/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs"); + } + private static void generateInjectorForTopDownAnalyzerForJvm() throws IOException { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false); generateInjectorForTopDownAnalyzerCommon(generator); diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java new file mode 100644 index 00000000000..e4ca6960deb --- /dev/null +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -0,0 +1,214 @@ +/* + * Copyright 2010-2012 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 org.jetbrains.jet.lang.resolve.TopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext; +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.DescriptorResolver; +import com.intellij.openapi.project.Project; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.resolve.DeclarationResolver; +import org.jetbrains.jet.lang.resolve.AnnotationResolver; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; +import org.jetbrains.jet.lang.resolve.TypeResolver; +import org.jetbrains.jet.lang.resolve.calls.OverloadingConflictResolver; +import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.resolve.DelegationResolver; +import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; +import org.jetbrains.jet.lang.resolve.OverloadResolver; +import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import com.intellij.openapi.project.Project; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.annotations.NotNull; + +/* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ +public class InjectorForTopDownAnalyzerForJs { + + private TopDownAnalyzer topDownAnalyzer; + private TopDownAnalysisContext topDownAnalysisContext; + private BodyResolver bodyResolver; + private ControlFlowAnalyzer controlFlowAnalyzer; + private DeclarationsChecker declarationsChecker; + private DescriptorResolver descriptorResolver; + private final Project project; + private final TopDownAnalysisParameters topDownAnalysisParameters; + private final ObservableBindingTrace observableBindingTrace; + + public InjectorForTopDownAnalyzerForJs( + @NotNull Project project, + @NotNull TopDownAnalysisParameters topDownAnalysisParameters, + @NotNull ObservableBindingTrace observableBindingTrace, + @NotNull ModuleDescriptor moduleDescriptor, + JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory, + @NotNull ModuleConfiguration moduleConfiguration + ) { + this.topDownAnalyzer = new TopDownAnalyzer(); + this.topDownAnalysisContext = new TopDownAnalysisContext(); + this.bodyResolver = new BodyResolver(); + this.controlFlowAnalyzer = new ControlFlowAnalyzer(); + this.declarationsChecker = new DeclarationsChecker(); + this.descriptorResolver = new DescriptorResolver(); + this.project = project; + this.topDownAnalysisParameters = topDownAnalysisParameters; + this.observableBindingTrace = observableBindingTrace; + DeclarationResolver declarationResolver = new DeclarationResolver(); + AnnotationResolver annotationResolver = new AnnotationResolver(); + CallResolver callResolver = new CallResolver(); + ExpressionTypingServices expressionTypingServices = new ExpressionTypingServices(); + TypeResolver typeResolver = new TypeResolver(); + OverloadingConflictResolver overloadingConflictResolver = new OverloadingConflictResolver(); + ImportsResolver importsResolver = new ImportsResolver(); + DelegationResolver delegationResolver = new DelegationResolver(); + NamespaceFactoryImpl namespaceFactoryImpl = new NamespaceFactoryImpl(); + OverloadResolver overloadResolver = new OverloadResolver(); + OverrideResolver overrideResolver = new OverrideResolver(); + TypeHierarchyResolver typeHierarchyResolver = new TypeHierarchyResolver(); + + this.topDownAnalyzer.setBodyResolver(bodyResolver); + this.topDownAnalyzer.setContext(topDownAnalysisContext); + this.topDownAnalyzer.setControlFlowAnalyzer(controlFlowAnalyzer); + this.topDownAnalyzer.setDeclarationResolver(declarationResolver); + this.topDownAnalyzer.setDeclarationsChecker(declarationsChecker); + this.topDownAnalyzer.setDelegationResolver(delegationResolver); + this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); + this.topDownAnalyzer.setNamespaceFactory(namespaceFactoryImpl); + this.topDownAnalyzer.setOverloadResolver(overloadResolver); + this.topDownAnalyzer.setOverrideResolver(overrideResolver); + this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters); + this.topDownAnalyzer.setTrace(observableBindingTrace); + this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); + + this.topDownAnalysisContext.setTopDownAnalysisParameters(topDownAnalysisParameters); + + this.bodyResolver.setCallResolver(callResolver); + this.bodyResolver.setContext(topDownAnalysisContext); + this.bodyResolver.setDescriptorResolver(descriptorResolver); + this.bodyResolver.setExpressionTypingServices(expressionTypingServices); + this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); + this.bodyResolver.setTrace(observableBindingTrace); + + this.controlFlowAnalyzer.setContext(topDownAnalysisContext); + this.controlFlowAnalyzer.setFlowDataTraceFactory(jetControlFlowDataTraceFactory); + this.controlFlowAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters); + this.controlFlowAnalyzer.setTrace(observableBindingTrace); + + this.declarationsChecker.setContext(topDownAnalysisContext); + this.declarationsChecker.setTrace(observableBindingTrace); + + this.descriptorResolver.setAnnotationResolver(annotationResolver); + this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); + this.descriptorResolver.setTypeResolver(typeResolver); + + declarationResolver.setAnnotationResolver(annotationResolver); + declarationResolver.setContext(topDownAnalysisContext); + declarationResolver.setDescriptorResolver(descriptorResolver); + declarationResolver.setImportsResolver(importsResolver); + declarationResolver.setTrace(observableBindingTrace); + + annotationResolver.setCallResolver(callResolver); + annotationResolver.setExpressionTypingServices(expressionTypingServices); + + callResolver.setDescriptorResolver(descriptorResolver); + callResolver.setExpressionTypingServices(expressionTypingServices); + callResolver.setOverloadingConflictResolver(overloadingConflictResolver); + callResolver.setTypeResolver(typeResolver); + + expressionTypingServices.setCallResolver(callResolver); + expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setProject(project); + expressionTypingServices.setTypeResolver(typeResolver); + + typeResolver.setAnnotationResolver(annotationResolver); + typeResolver.setDescriptorResolver(descriptorResolver); + + importsResolver.setConfiguration(moduleConfiguration); + importsResolver.setContext(topDownAnalysisContext); + importsResolver.setTrace(observableBindingTrace); + + delegationResolver.setContext(topDownAnalysisContext); + delegationResolver.setTrace(observableBindingTrace); + + namespaceFactoryImpl.setConfiguration(moduleConfiguration); + namespaceFactoryImpl.setModuleDescriptor(moduleDescriptor); + namespaceFactoryImpl.setTrace(observableBindingTrace); + + overloadResolver.setContext(topDownAnalysisContext); + overloadResolver.setTrace(observableBindingTrace); + + overrideResolver.setContext(topDownAnalysisContext); + overrideResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); + overrideResolver.setTrace(observableBindingTrace); + + typeHierarchyResolver.setContext(topDownAnalysisContext); + typeHierarchyResolver.setDescriptorResolver(descriptorResolver); + typeHierarchyResolver.setImportsResolver(importsResolver); + typeHierarchyResolver.setNamespaceFactory(namespaceFactoryImpl); + typeHierarchyResolver.setTrace(observableBindingTrace); + + } + + public TopDownAnalyzer getTopDownAnalyzer() { + return this.topDownAnalyzer; + } + + public TopDownAnalysisContext getTopDownAnalysisContext() { + return this.topDownAnalysisContext; + } + + public BodyResolver getBodyResolver() { + return this.bodyResolver; + } + + public ControlFlowAnalyzer getControlFlowAnalyzer() { + return this.controlFlowAnalyzer; + } + + public DeclarationsChecker getDeclarationsChecker() { + return this.declarationsChecker; + } + + public DescriptorResolver getDescriptorResolver() { + return this.descriptorResolver; + } + + public Project getProject() { + return this.project; + } + + public TopDownAnalysisParameters getTopDownAnalysisParameters() { + return this.topDownAnalysisParameters; + } + + public ObservableBindingTrace getObservableBindingTrace() { + return this.observableBindingTrace; + } + +} diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index e611951cb0f..11eebf75275 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -22,9 +22,12 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.di.InjectorForTopDownAnalyzerBasic; +import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs; import org.jetbrains.jet.lang.DefaultModuleConfiguration; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetImportDirective; @@ -59,11 +62,19 @@ public final class AnalyzerFacadeForJS { public static BindingContext analyzeFiles(@NotNull List files, @NotNull Config config) { Project project = config.getProject(); - return AnalyzingUtils.analyzeFiles(project, - JsConfiguration.jsLibConfiguration(project), - withJsLibAdded(files, config), - notLibFiles(config.getLibFiles()), - JetControlFlowDataTraceFactory.EMPTY); + BindingTraceContext bindingTraceContext = new BindingTraceContext(); + + final ModuleDescriptor owner = new ModuleDescriptor(""); + + TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( + notLibFiles(config.getLibFiles()), false, false); + + InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( + project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, + JetControlFlowDataTraceFactory.EMPTY, JsConfiguration.jsLibConfiguration(project)); + + injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(withJsLibAdded(files, config)); + return bindingTraceContext.getBindingContext(); } private static void checkForErrors(@NotNull List allFiles, @NotNull BindingContext bindingContext) { @@ -96,14 +107,17 @@ public final class AnalyzerFacadeForJS { public static BindingContext analyzeNamespace(@NotNull JetFile file) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); Project project = file.getProject(); - AnalyzingUtils.analyzeFilesWithGivenTrace( - project, - JsConfiguration.jsLibConfiguration(project), - Collections.singletonList(file), - Predicates.alwaysTrue(), - JetControlFlowDataTraceFactory.EMPTY, - bindingTraceContext - ); + + final ModuleDescriptor owner = new ModuleDescriptor(""); + + TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( + Predicates.alwaysTrue(), false, false); + + InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( + project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, + JetControlFlowDataTraceFactory.EMPTY, JsConfiguration.jsLibConfiguration(project)); + + injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(Collections.singletonList(file)); return bindingTraceContext.getBindingContext(); }