azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

injector to analyze js

Browse Source
This commit is contained in:
Stepan Koltsov
2012-03-26 17:42:04 +04:00
parent 0a08f811ea
commit bc17c7b4f3
7 changed files with 258 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java
-1
View File
@@ -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
-1
View File
@@ -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
-23
View File
@@ -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
+9 -46
View File
@@ -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
+8
View File
@@ -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
+214
View File
@@ -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
+27 -13
View File
@@ -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,
JsConfiguration.jsLibConfiguration(project),
withJsLibAdded(files, config),
notLibFiles(config.getLibFiles()),
JetControlFlowDataTraceFactory.EMPTY);
BindingTraceContext bindingTraceContext = new BindingTraceContext();
final ModuleDescriptor owner = new ModuleDescriptor("<module>");
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,
JsConfiguration.jsLibConfiguration(project),
Collections.singletonList(file),
Predicates.<PsiFile>alwaysTrue(),
JetControlFlowDataTraceFactory.EMPTY,
bindingTraceContext
);
final ModuleDescriptor owner = new ModuleDescriptor("<module>");
TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
Predicates.<PsiFile>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();
}