From 9290f55badf822522afc55be09f2a946e887e636 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Wed, 13 Jun 2012 19:27:04 +0400 Subject: [PATCH] JavaDescriptorResolver is not needed for body resolver * create InjectorForBodyResolve * split ScriptDescriptor into ScriptDeclarationResolve and ScriptBodyResolver --- .../di/InjectorForTopDownAnalyzerForJvm.java | 30 ++-- .../resolve/java/AnalyzerFacadeForJVM.java | 8 +- .../jet/di/InjectorForBodyResolve.java | 144 ++++++++++++++++++ .../di/InjectorForTopDownAnalyzerBasic.java | 44 +++--- .../lang/descriptors/ScriptDescriptor.java | 7 +- .../jet/lang/resolve/BodyResolver.java | 8 +- .../jet/lang/resolve/DeclarationResolver.java | 9 ++ .../jet/lang/resolve/ScriptBodyResolver.java | 88 +++++++++++ ...esolver.java => ScriptHeaderResolver.java} | 37 +---- .../lang/resolve/TypeHierarchyResolver.java | 8 +- .../jet/di/AllInjectorsGenerator.java | 15 ++ .../di/InjectorForTopDownAnalyzerForJs.java | 44 +++--- .../k2js/analyze/AnalyzerFacadeForJS.java | 7 +- 13 files changed, 346 insertions(+), 103 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptBodyResolver.java rename compiler/frontend/src/org/jetbrains/jet/lang/resolve/{ScriptResolver.java => ScriptHeaderResolver.java} (82%) 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 ee27d69b7fb..43d976d69a2 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -41,11 +41,12 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.OverloadingConflictResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.jet.lang.resolve.DelegationResolver; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; -import org.jetbrains.jet.lang.resolve.ScriptResolver; +import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; import com.intellij.openapi.project.Project; @@ -83,11 +84,12 @@ public class InjectorForTopDownAnalyzerForJvm { private QualifiedExpressionResolver qualifiedExpressionResolver; private OverloadingConflictResolver overloadingConflictResolver; private ImportsResolver importsResolver; + private ScriptHeaderResolver scriptHeaderResolver; private DelegationResolver delegationResolver; private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; private TypeHierarchyResolver typeHierarchyResolver; - private ScriptResolver scriptResolver; + private ScriptBodyResolver scriptBodyResolver; private JavaSemanticServices javaSemanticServices; private JavaTypeTransformer javaTypeTransformer; @@ -122,11 +124,12 @@ public class InjectorForTopDownAnalyzerForJvm { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.overloadingConflictResolver = new OverloadingConflictResolver(); this.importsResolver = new ImportsResolver(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); this.delegationResolver = new DelegationResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); this.typeHierarchyResolver = new TypeHierarchyResolver(); - this.scriptResolver = new ScriptResolver(); + this.scriptBodyResolver = new ScriptBodyResolver(); this.javaSemanticServices = new JavaSemanticServices(); this.javaTypeTransformer = new JavaTypeTransformer(); @@ -149,7 +152,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.bodyResolver.setDeclarationsChecker(declarationsChecker); this.bodyResolver.setDescriptorResolver(descriptorResolver); this.bodyResolver.setExpressionTypingServices(expressionTypingServices); - this.bodyResolver.setScriptResolver(scriptResolver); + this.bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver); this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); this.bodyResolver.setTrace(bindingTrace); @@ -183,6 +186,7 @@ public class InjectorForTopDownAnalyzerForJvm { declarationResolver.setContext(topDownAnalysisContext); declarationResolver.setDescriptorResolver(descriptorResolver); declarationResolver.setImportsResolver(importsResolver); + declarationResolver.setScriptHeaderResolver(scriptHeaderResolver); declarationResolver.setTrace(bindingTrace); annotationResolver.setCallResolver(callResolver); @@ -207,6 +211,12 @@ public class InjectorForTopDownAnalyzerForJvm { importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); + scriptHeaderResolver.setContext(topDownAnalysisContext); + scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(javaDescriptorResolver); + scriptHeaderResolver.setNamespaceFactory(namespaceFactory); + scriptHeaderResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); + scriptHeaderResolver.setTrace(bindingTrace); + delegationResolver.setContext(topDownAnalysisContext); delegationResolver.setTrace(bindingTrace); @@ -221,16 +231,12 @@ public class InjectorForTopDownAnalyzerForJvm { typeHierarchyResolver.setDescriptorResolver(descriptorResolver); typeHierarchyResolver.setImportsResolver(importsResolver); typeHierarchyResolver.setNamespaceFactory(namespaceFactory); - typeHierarchyResolver.setScriptResolver(scriptResolver); + typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); typeHierarchyResolver.setTrace(bindingTrace); - scriptResolver.setContext(topDownAnalysisContext); - scriptResolver.setDependencyClassByQualifiedNameResolver(javaDescriptorResolver); - scriptResolver.setExpressionTypingServices(expressionTypingServices); - scriptResolver.setModuleDescriptor(moduleDescriptor); - scriptResolver.setNamespaceFactory(namespaceFactory); - scriptResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); - scriptResolver.setTrace(bindingTrace); + scriptBodyResolver.setContext(topDownAnalysisContext); + scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); + scriptBodyResolver.setTrace(bindingTrace); javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); javaSemanticServices.setPsiClassFinder(psiClassFinderForJvm); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index af36c76acb5..e87b74b42cf 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -23,6 +23,7 @@ import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.analyzer.AnalyzerFacade; +import org.jetbrains.jet.di.InjectorForBodyResolve; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetFile; @@ -71,7 +72,6 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { ) { return analyzeBodiesInFilesWithJavaIntegration( project, scriptParameters, filesForBodiesResolve, - compilerDependenciesForProduction(CompilerSpecialMode.REGULAR), headersTraceContext, bodiesResolveContext); } @@ -137,19 +137,17 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { public static AnalyzeExhaust analyzeBodiesInFilesWithJavaIntegration( Project project, List scriptParameters, Predicate filesToAnalyzeCompletely, - @NotNull CompilerDependencies compilerDependencies, @NotNull BindingTrace traceContext, @NotNull BodiesResolveContext bodiesResolveContext) { - final ModuleDescriptor owner = new ModuleDescriptor(Name.special("")); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( filesToAnalyzeCompletely, false, false, scriptParameters); bodiesResolveContext.setTopDownAnalysisParameters(topDownAnalysisParameters); - InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm( + InjectorForBodyResolve injector = new InjectorForBodyResolve( project, topDownAnalysisParameters, - new ObservableBindingTrace(traceContext), owner, compilerDependencies); + new ObservableBindingTrace(traceContext)); try { injector.getBodyResolver().resolveBodies(bodiesResolveContext); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java new file mode 100644 index 00000000000..1115a0dd0c8 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java @@ -0,0 +1,144 @@ +/* + * 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.BodyResolver; +import com.intellij.openapi.project.Project; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.DescriptorResolver; +import org.jetbrains.jet.lang.resolve.AnnotationResolver; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; +import org.jetbrains.jet.lang.resolve.TypeResolver; +import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.calls.OverloadingConflictResolver; +import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; +import org.jetbrains.jet.lang.resolve.DeclarationsChecker; +import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext; +import com.intellij.openapi.project.Project; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; + +/* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ +public class InjectorForBodyResolve { + + private BodyResolver bodyResolver; + private final Project project; + private final TopDownAnalysisParameters topDownAnalysisParameters; + private final BindingTrace bindingTrace; + private CallResolver callResolver; + private DescriptorResolver descriptorResolver; + private AnnotationResolver annotationResolver; + private ExpressionTypingServices expressionTypingServices; + private TypeResolver typeResolver; + private QualifiedExpressionResolver qualifiedExpressionResolver; + private OverloadingConflictResolver overloadingConflictResolver; + private ControlFlowAnalyzer controlFlowAnalyzer; + private DeclarationsChecker declarationsChecker; + private ScriptBodyResolver scriptBodyResolver; + private TopDownAnalysisContext topDownAnalysisContext; + + public InjectorForBodyResolve( + @NotNull Project project, + @NotNull TopDownAnalysisParameters topDownAnalysisParameters, + @NotNull BindingTrace bindingTrace + ) { + this.bodyResolver = new BodyResolver(); + this.project = project; + this.topDownAnalysisParameters = topDownAnalysisParameters; + this.bindingTrace = bindingTrace; + this.callResolver = new CallResolver(); + this.descriptorResolver = new DescriptorResolver(); + this.annotationResolver = new AnnotationResolver(); + this.expressionTypingServices = new ExpressionTypingServices(); + this.typeResolver = new TypeResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.overloadingConflictResolver = new OverloadingConflictResolver(); + this.controlFlowAnalyzer = new ControlFlowAnalyzer(); + this.declarationsChecker = new DeclarationsChecker(); + this.scriptBodyResolver = new ScriptBodyResolver(); + this.topDownAnalysisContext = new TopDownAnalysisContext(); + + this.bodyResolver.setCallResolver(callResolver); + this.bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); + this.bodyResolver.setDeclarationsChecker(declarationsChecker); + this.bodyResolver.setDescriptorResolver(descriptorResolver); + this.bodyResolver.setExpressionTypingServices(expressionTypingServices); + this.bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver); + this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); + this.bodyResolver.setTrace(bindingTrace); + + callResolver.setDescriptorResolver(descriptorResolver); + callResolver.setExpressionTypingServices(expressionTypingServices); + callResolver.setOverloadingConflictResolver(overloadingConflictResolver); + callResolver.setTypeResolver(typeResolver); + + descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setExpressionTypingServices(expressionTypingServices); + descriptorResolver.setTypeResolver(typeResolver); + + annotationResolver.setCallResolver(callResolver); + annotationResolver.setExpressionTypingServices(expressionTypingServices); + + expressionTypingServices.setCallResolver(callResolver); + expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setProject(project); + expressionTypingServices.setTypeResolver(typeResolver); + + typeResolver.setAnnotationResolver(annotationResolver); + typeResolver.setDescriptorResolver(descriptorResolver); + typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); + + controlFlowAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters); + controlFlowAnalyzer.setTrace(bindingTrace); + + declarationsChecker.setTrace(bindingTrace); + + scriptBodyResolver.setContext(topDownAnalysisContext); + scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); + scriptBodyResolver.setTrace(bindingTrace); + + topDownAnalysisContext.setTopDownAnalysisParameters(topDownAnalysisParameters); + + } + + @PreDestroy + public void destroy() { + } + + public BodyResolver getBodyResolver() { + return this.bodyResolver; + } + + public Project getProject() { + return this.project; + } + + public TopDownAnalysisParameters getTopDownAnalysisParameters() { + return this.topDownAnalysisParameters; + } + + public BindingTrace getBindingTrace() { + return this.bindingTrace; + } + +} diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 1dfbf666b6a..cb14693915d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; +import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -37,12 +38,12 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.OverloadingConflictResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; 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 org.jetbrains.jet.lang.resolve.ScriptResolver; +import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -66,6 +67,7 @@ public class InjectorForTopDownAnalyzerBasic { private final ModuleDescriptor moduleDescriptor; private final ModuleConfiguration moduleConfiguration; private DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy; + private NamespaceFactoryImpl namespaceFactory; private DeclarationResolver declarationResolver; private AnnotationResolver annotationResolver; private CallResolver callResolver; @@ -74,12 +76,12 @@ public class InjectorForTopDownAnalyzerBasic { private QualifiedExpressionResolver qualifiedExpressionResolver; private OverloadingConflictResolver overloadingConflictResolver; private ImportsResolver importsResolver; + private ScriptHeaderResolver scriptHeaderResolver; private DelegationResolver delegationResolver; - private NamespaceFactoryImpl namespaceFactory; private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; private TypeHierarchyResolver typeHierarchyResolver; - private ScriptResolver scriptResolver; + private ScriptBodyResolver scriptBodyResolver; public InjectorForTopDownAnalyzerBasic( @NotNull Project project, @@ -100,6 +102,7 @@ public class InjectorForTopDownAnalyzerBasic { this.moduleDescriptor = moduleDescriptor; this.moduleConfiguration = moduleConfiguration; this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl(); + this.namespaceFactory = new NamespaceFactoryImpl(); this.declarationResolver = new DeclarationResolver(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -108,12 +111,12 @@ public class InjectorForTopDownAnalyzerBasic { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.overloadingConflictResolver = new OverloadingConflictResolver(); this.importsResolver = new ImportsResolver(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); this.delegationResolver = new DelegationResolver(); - this.namespaceFactory = new NamespaceFactoryImpl(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); this.typeHierarchyResolver = new TypeHierarchyResolver(); - this.scriptResolver = new ScriptResolver(); + this.scriptBodyResolver = new ScriptBodyResolver(); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setContext(topDownAnalysisContext); @@ -134,7 +137,7 @@ public class InjectorForTopDownAnalyzerBasic { this.bodyResolver.setDeclarationsChecker(declarationsChecker); this.bodyResolver.setDescriptorResolver(descriptorResolver); this.bodyResolver.setExpressionTypingServices(expressionTypingServices); - this.bodyResolver.setScriptResolver(scriptResolver); + this.bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver); this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); this.bodyResolver.setTrace(bindingTrace); @@ -147,10 +150,15 @@ public class InjectorForTopDownAnalyzerBasic { this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); this.descriptorResolver.setTypeResolver(typeResolver); + namespaceFactory.setConfiguration(moduleConfiguration); + namespaceFactory.setModuleDescriptor(moduleDescriptor); + namespaceFactory.setTrace(bindingTrace); + declarationResolver.setAnnotationResolver(annotationResolver); declarationResolver.setContext(topDownAnalysisContext); declarationResolver.setDescriptorResolver(descriptorResolver); declarationResolver.setImportsResolver(importsResolver); + declarationResolver.setScriptHeaderResolver(scriptHeaderResolver); declarationResolver.setTrace(bindingTrace); annotationResolver.setCallResolver(callResolver); @@ -175,13 +183,15 @@ public class InjectorForTopDownAnalyzerBasic { importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); + scriptHeaderResolver.setContext(topDownAnalysisContext); + scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy); + scriptHeaderResolver.setNamespaceFactory(namespaceFactory); + scriptHeaderResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); + scriptHeaderResolver.setTrace(bindingTrace); + delegationResolver.setContext(topDownAnalysisContext); delegationResolver.setTrace(bindingTrace); - namespaceFactory.setConfiguration(moduleConfiguration); - namespaceFactory.setModuleDescriptor(moduleDescriptor); - namespaceFactory.setTrace(bindingTrace); - overloadResolver.setContext(topDownAnalysisContext); overloadResolver.setTrace(bindingTrace); @@ -193,16 +203,12 @@ public class InjectorForTopDownAnalyzerBasic { typeHierarchyResolver.setDescriptorResolver(descriptorResolver); typeHierarchyResolver.setImportsResolver(importsResolver); typeHierarchyResolver.setNamespaceFactory(namespaceFactory); - typeHierarchyResolver.setScriptResolver(scriptResolver); + typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); typeHierarchyResolver.setTrace(bindingTrace); - scriptResolver.setContext(topDownAnalysisContext); - scriptResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy); - scriptResolver.setExpressionTypingServices(expressionTypingServices); - scriptResolver.setModuleDescriptor(moduleDescriptor); - scriptResolver.setNamespaceFactory(namespaceFactory); - scriptResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); - scriptResolver.setTrace(bindingTrace); + scriptBodyResolver.setContext(topDownAnalysisContext); + scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); + scriptBodyResolver.setTrace(bindingTrace); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java index 002a60f22ca..161da23bf37 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java @@ -44,9 +44,8 @@ public class ScriptDescriptor extends DeclarationDescriptorImpl { super(containingDeclaration, Collections.emptyList(), NAME); } - public void initialize(@NotNull JetType returnType, @NotNull List valueParameters) { + public void initialize(@NotNull JetType returnType) { this.returnType = returnType; - this.valueParameters = valueParameters; scriptCodeDescriptor.initialize(implicitReceiver, valueParameters, returnType); } @@ -79,4 +78,8 @@ public class ScriptDescriptor extends DeclarationDescriptorImpl { public R accept(DeclarationDescriptorVisitor visitor, D data) { return visitor.visitScriptDescriptor(this, data); } + + public void setValueParameters(@NotNull List valueParameters) { + this.valueParameters = valueParameters; + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java index f91b4cb614d..f0967ee2551 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java @@ -115,7 +115,7 @@ public class BodyResolver { @NotNull private DescriptorResolver descriptorResolver; @NotNull - private ScriptResolver scriptResolver; + private ScriptBodyResolver scriptBodyResolverResolver; @NotNull private ExpressionTypingServices expressionTypingServices; @NotNull @@ -138,8 +138,8 @@ public class BodyResolver { } @Inject - public void setScriptResolver(@NotNull ScriptResolver scriptResolver) { - this.scriptResolver = scriptResolver; + public void setScriptBodyResolverResolver(@NotNull ScriptBodyResolver scriptBodyResolverResolver) { + this.scriptBodyResolverResolver = scriptBodyResolverResolver; } @Inject @@ -182,7 +182,7 @@ public class BodyResolver { resolveSecondaryConstructorBodies(); resolveFunctionBodies(); - scriptResolver.resolveScripts(); + scriptBodyResolverResolver.resolveScriptBodies(); if (!topDownAnalysisParameters.isDeclaredLocally()) { computeDeferredTypes(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java index 2903b732ac1..c883062118b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java @@ -50,6 +50,8 @@ public class DeclarationResolver { @NotNull private DescriptorResolver descriptorResolver; @NotNull + private ScriptHeaderResolver scriptHeaderResolver; + @NotNull private BindingTrace trace; @@ -78,6 +80,11 @@ public class DeclarationResolver { this.trace = trace; } + @Inject + public void setScriptHeaderResolver(@NotNull ScriptHeaderResolver scriptHeaderResolver) { + this.scriptHeaderResolver = scriptHeaderResolver; + } + public void process(@NotNull JetScope rootScope) { @@ -152,6 +159,8 @@ public class DeclarationResolver { classDescriptor.getBuilder()); } + scriptHeaderResolver.resolveScriptDeclarations(); + // TODO : Extensions } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptBodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptBodyResolver.java new file mode 100644 index 00000000000..d3d8262d944 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptBodyResolver.java @@ -0,0 +1,88 @@ +/* + * 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.lang.resolve; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; +import org.jetbrains.jet.lang.psi.JetScript; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import org.jetbrains.jet.lang.types.ErrorUtils; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.expressions.CoercionStrategy; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; + +import javax.inject.Inject; +import java.util.Map; + +import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; + +/** + * @author Stepan Koltsov + */ +public class ScriptBodyResolver { + + @NotNull + private TopDownAnalysisContext context; + @NotNull + private ExpressionTypingServices expressionTypingServices; + @NotNull + private BindingTrace trace; + + @Inject + public void setContext(@NotNull TopDownAnalysisContext context) { + this.context = context; + } + + @Inject + public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { + this.expressionTypingServices = expressionTypingServices; + } + + @Inject + public void setTrace(@NotNull BindingTrace trace) { + this.trace = trace; + } + + + + public void resolveScriptBodies() { + for (Map.Entry e : context.getScripts().entrySet()) { + JetScript declaration = e.getKey(); + ScriptDescriptor descriptor = e.getValue(); + WritableScope scope = context.getScriptScopes().get(declaration); + + // TODO: lock in resolveScriptDeclarations + scope.changeLockLevel(WritableScope.LockLevel.READING); + + ExpressionTypingContext context = ExpressionTypingContext.newContext( + expressionTypingServices, + trace, + scope, + DataFlowInfo.EMPTY, + NO_EXPECTED_TYPE, + false); + JetType returnType = expressionTypingServices.getBlockReturnedType(scope, declaration.getBlockExpression(), CoercionStrategy.NO_COERCION, context, trace); + if (returnType == null) { + returnType = ErrorUtils.createErrorType("getBlockReturnedType returned null"); + } + descriptor.initialize(returnType); + } + } + +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptHeaderResolver.java similarity index 82% rename from compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptResolver.java rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptHeaderResolver.java index 9ca7e029313..ff4e02c1736 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptHeaderResolver.java @@ -48,19 +48,15 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; /** * @author Stepan Koltsov */ -public class ScriptResolver { +public class ScriptHeaderResolver { @NotNull private NamespaceFactory namespaceFactory; @NotNull private DependencyClassByQualifiedNameResolver dependencyClassByQualifiedNameResolver; @NotNull - private ModuleDescriptor moduleDescriptor; - @NotNull private TopDownAnalysisContext context; @NotNull - private ExpressionTypingServices expressionTypingServices; - @NotNull private BindingTrace trace; @NotNull private TopDownAnalysisParameters topDownAnalysisParameters; @@ -75,21 +71,11 @@ public class ScriptResolver { this.dependencyClassByQualifiedNameResolver = dependencyClassByQualifiedNameResolver; } - @Inject - public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) { - this.moduleDescriptor = moduleDescriptor; - } - @Inject public void setContext(@NotNull TopDownAnalysisContext context) { this.context = context; } - @Inject - public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { - this.expressionTypingServices = expressionTypingServices; - } - @Inject public void setTrace(@NotNull BindingTrace trace) { this.trace = trace; @@ -143,9 +129,7 @@ public class ScriptResolver { trace.record(BindingContext.SCRIPT, script, scriptDescriptor); } - - - public void resolveScripts() { + public void resolveScriptDeclarations() { for (Map.Entry e : context.getScripts().entrySet()) { JetScript declaration = e.getKey(); ScriptDescriptor descriptor = e.getValue(); @@ -163,23 +147,8 @@ public class ScriptResolver { ++index; } - scope.changeLockLevel(WritableScope.LockLevel.READING); - - ExpressionTypingContext context = ExpressionTypingContext.newContext( - expressionTypingServices, - trace, - scope, - DataFlowInfo.EMPTY, - NO_EXPECTED_TYPE, - false); - JetType returnType = expressionTypingServices.getBlockReturnedType(scope, declaration.getBlockExpression(), CoercionStrategy.NO_COERCION, context, trace); - if (returnType == null) { - returnType = ErrorUtils.createErrorType("getBlockReturnedType returned null"); - } - descriptor.initialize(returnType, valueParameters); + descriptor.setValueParameters(valueParameters); } } - - } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java index a6a94e936f2..2abd4eea273 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -54,7 +54,7 @@ public class TypeHierarchyResolver { @NotNull private DescriptorResolver descriptorResolver; @NotNull - private ScriptResolver scriptResolver; + private ScriptHeaderResolver scriptHeaderResolver; @NotNull private NamespaceFactoryImpl namespaceFactory; @NotNull @@ -79,8 +79,8 @@ public class TypeHierarchyResolver { } @Inject - public void setScriptResolver(@NotNull ScriptResolver scriptResolver) { - this.scriptResolver = scriptResolver; + public void setScriptHeaderResolver(@NotNull ScriptHeaderResolver scriptHeaderResolver) { + this.scriptHeaderResolver = scriptHeaderResolver; } @Inject @@ -195,7 +195,7 @@ public class TypeHierarchyResolver { public void visitJetFile(JetFile file) { if (file.isScript()) { JetScript script = file.getScript(); - scriptResolver.processScriptHierarchy(script, outerScope); + scriptHeaderResolver.processScriptHierarchy(script, outerScope); return; } diff --git a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java index c804bb9205d..5700ce78f24 100644 --- a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java +++ b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java @@ -50,6 +50,7 @@ public class AllInjectorsGenerator { generateInjectorForJvmCodegen(); generateInjectorForJetTypeMapper(); generateInjectorForLazyResolve(); + generateInjectorForBodyResolve(); } private static void generateInjectorForLazyResolve() throws IOException { @@ -71,6 +72,7 @@ public class AllInjectorsGenerator { generateInjectorForTopDownAnalyzerCommon(generator); generator.addParameter(ModuleConfiguration.class); generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class); + generator.addField(NamespaceFactoryImpl.class); generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic"); } @@ -79,6 +81,7 @@ public class AllInjectorsGenerator { generateInjectorForTopDownAnalyzerCommon(generator); generator.addParameter(ModuleConfiguration.class); generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class); + generator.addField(NamespaceFactoryImpl.class); generator.generate("js/js.translator/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs"); } @@ -190,4 +193,16 @@ public class AllInjectorsGenerator { generator.generate("compiler/backend/src", "org.jetbrains.jet.di", "InjectorForJetTypeMapper"); } + private static void generateInjectorForBodyResolve() throws IOException { + DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false); + // Fields + generator.addPublicField(BodyResolver.class); + + // Parameters + generator.addPublicParameter(Project.class); + generator.addPublicParameter(TopDownAnalysisParameters.class); + generator.addPublicParameter(BindingTrace.class); + generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForBodyResolve"); + } + } diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index bf975c7fb7a..8488c0eff8a 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; +import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -37,12 +38,12 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.OverloadingConflictResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; 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 org.jetbrains.jet.lang.resolve.ScriptResolver; +import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -66,6 +67,7 @@ public class InjectorForTopDownAnalyzerForJs { private final ModuleDescriptor moduleDescriptor; private final ModuleConfiguration moduleConfiguration; private DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy; + private NamespaceFactoryImpl namespaceFactory; private DeclarationResolver declarationResolver; private AnnotationResolver annotationResolver; private CallResolver callResolver; @@ -74,12 +76,12 @@ public class InjectorForTopDownAnalyzerForJs { private QualifiedExpressionResolver qualifiedExpressionResolver; private OverloadingConflictResolver overloadingConflictResolver; private ImportsResolver importsResolver; + private ScriptHeaderResolver scriptHeaderResolver; private DelegationResolver delegationResolver; - private NamespaceFactoryImpl namespaceFactory; private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; private TypeHierarchyResolver typeHierarchyResolver; - private ScriptResolver scriptResolver; + private ScriptBodyResolver scriptBodyResolver; public InjectorForTopDownAnalyzerForJs( @NotNull Project project, @@ -100,6 +102,7 @@ public class InjectorForTopDownAnalyzerForJs { this.moduleDescriptor = moduleDescriptor; this.moduleConfiguration = moduleConfiguration; this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl(); + this.namespaceFactory = new NamespaceFactoryImpl(); this.declarationResolver = new DeclarationResolver(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -108,12 +111,12 @@ public class InjectorForTopDownAnalyzerForJs { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.overloadingConflictResolver = new OverloadingConflictResolver(); this.importsResolver = new ImportsResolver(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); this.delegationResolver = new DelegationResolver(); - this.namespaceFactory = new NamespaceFactoryImpl(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); this.typeHierarchyResolver = new TypeHierarchyResolver(); - this.scriptResolver = new ScriptResolver(); + this.scriptBodyResolver = new ScriptBodyResolver(); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setContext(topDownAnalysisContext); @@ -134,7 +137,7 @@ public class InjectorForTopDownAnalyzerForJs { this.bodyResolver.setDeclarationsChecker(declarationsChecker); this.bodyResolver.setDescriptorResolver(descriptorResolver); this.bodyResolver.setExpressionTypingServices(expressionTypingServices); - this.bodyResolver.setScriptResolver(scriptResolver); + this.bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver); this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); this.bodyResolver.setTrace(bindingTrace); @@ -147,10 +150,15 @@ public class InjectorForTopDownAnalyzerForJs { this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); this.descriptorResolver.setTypeResolver(typeResolver); + namespaceFactory.setConfiguration(moduleConfiguration); + namespaceFactory.setModuleDescriptor(moduleDescriptor); + namespaceFactory.setTrace(bindingTrace); + declarationResolver.setAnnotationResolver(annotationResolver); declarationResolver.setContext(topDownAnalysisContext); declarationResolver.setDescriptorResolver(descriptorResolver); declarationResolver.setImportsResolver(importsResolver); + declarationResolver.setScriptHeaderResolver(scriptHeaderResolver); declarationResolver.setTrace(bindingTrace); annotationResolver.setCallResolver(callResolver); @@ -175,13 +183,15 @@ public class InjectorForTopDownAnalyzerForJs { importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); + scriptHeaderResolver.setContext(topDownAnalysisContext); + scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy); + scriptHeaderResolver.setNamespaceFactory(namespaceFactory); + scriptHeaderResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); + scriptHeaderResolver.setTrace(bindingTrace); + delegationResolver.setContext(topDownAnalysisContext); delegationResolver.setTrace(bindingTrace); - namespaceFactory.setConfiguration(moduleConfiguration); - namespaceFactory.setModuleDescriptor(moduleDescriptor); - namespaceFactory.setTrace(bindingTrace); - overloadResolver.setContext(topDownAnalysisContext); overloadResolver.setTrace(bindingTrace); @@ -193,16 +203,12 @@ public class InjectorForTopDownAnalyzerForJs { typeHierarchyResolver.setDescriptorResolver(descriptorResolver); typeHierarchyResolver.setImportsResolver(importsResolver); typeHierarchyResolver.setNamespaceFactory(namespaceFactory); - typeHierarchyResolver.setScriptResolver(scriptResolver); + typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); typeHierarchyResolver.setTrace(bindingTrace); - scriptResolver.setContext(topDownAnalysisContext); - scriptResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy); - scriptResolver.setExpressionTypingServices(expressionTypingServices); - scriptResolver.setModuleDescriptor(moduleDescriptor); - scriptResolver.setNamespaceFactory(namespaceFactory); - scriptResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); - scriptResolver.setTrace(bindingTrace); + scriptBodyResolver.setContext(topDownAnalysisContext); + scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); + scriptBodyResolver.setTrace(bindingTrace); } 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 5a39152ab82..4e0386b7ae6 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -24,6 +24,7 @@ import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.di.InjectorForBodyResolve; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs; import org.jetbrains.jet.lang.DefaultModuleConfiguration; import org.jetbrains.jet.lang.ModuleConfiguration; @@ -112,15 +113,13 @@ public final class AnalyzerFacadeForJS { @NotNull BodiesResolveContext bodiesResolveContext ) { Project project = config.getProject(); - final ModuleDescriptor owner = new ModuleDescriptor(Name.special("")); Predicate completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(completely, false, false, Collections.emptyList()); - InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( - project, topDownAnalysisParameters, new ObservableBindingTrace(traceContext), owner, - JsConfiguration.jsLibConfiguration(project)); + InjectorForBodyResolve injector = new InjectorForBodyResolve( + project, topDownAnalysisParameters, new ObservableBindingTrace(traceContext)); try { bodiesResolveContext.setTopDownAnalysisParameters(topDownAnalysisParameters);