injector to analyze js

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);

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);

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<JetFile> files,
-            @NotNull Predicate<PsiFile> 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<JetFile> files,
-            @NotNull Predicate<PsiFile> filesToAnalyzeCompletely,
-            @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory,
-            @NotNull BindingTraceContext bindingTraceContext) {
-
-        TopDownAnalyzer.doAnalyzeFilesWithGivenTrace(project, configuration, files, filesToAnalyzeCompletely, flowDataTraceFactory, bindingTraceContext);
-    }
-
 }

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<? extends PsiElement> declarations,
-            @NotNull Predicate<PsiFile> 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("<dummy for objec>");
 
-        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.<PsiElement>singletonList(object), Predicates.equalTo(object.getContainingFile()), JetControlFlowDataTraceFactory.EMPTY, ModuleConfiguration.EMPTY, true);
+        }, Collections.<PsiElement>singletonList(object));
     }
 
 
-    public static void doAnalyzeFilesWithGivenTrace(Project project, final ModuleConfiguration configuration, Collection<JetFile> files, Predicate<PsiFile> filesToAnalyzeCompletely, JetControlFlowDataTraceFactory flowDataTraceFactory, BindingTraceContext bindingTraceContext) {
-        final ModuleDescriptor owner = new ModuleDescriptor("<module>");
-
-        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<JetFile> files) {
         final WritableScope scope = new WritableScopeImpl(
                 JetScope.EMPTY, moduleDescriptor,

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);

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;
+    }
+
+}

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<JetFile> files,
                                               @NotNull Config config) {
         Project project = config.getProject();
-        return AnalyzingUtils.analyzeFiles(project,
+        BindingTraceContext bindingTraceContext = new BindingTraceContext();
-                                           JsConfiguration.jsLibConfiguration(project),
+
-                                           withJsLibAdded(files, config),
+        final ModuleDescriptor owner = new ModuleDescriptor("<module>");
-                                           notLibFiles(config.getLibFiles()),
+
-                                           JetControlFlowDataTraceFactory.EMPTY);
+        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<JetFile> 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,
+        final ModuleDescriptor owner = new ModuleDescriptor("<module>");
-                JsConfiguration.jsLibConfiguration(project),
+
-                Collections.singletonList(file),
+        TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
-                Predicates.<PsiFile>alwaysTrue(),
+                Predicates.<PsiFile>alwaysTrue(), false, false);
-                JetControlFlowDataTraceFactory.EMPTY,
+
-                bindingTraceContext
+        InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
-        );
+                project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner,
+                JetControlFlowDataTraceFactory.EMPTY, JsConfiguration.jsLibConfiguration(project));
+
+        injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(Collections.singletonList(file));
         return bindingTraceContext.getBindingContext();
     }