From 3c41df84194007d49e835278e545caf385c86dc8 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Thu, 22 Mar 2012 03:47:10 +0400 Subject: [PATCH] move BindingTrace to Injector from TopDownAnalysisContext It is necessary to make NamespaceFactoryImpl independent from TopDownAnalysisContext --- .../di/InjectorForTopDownAnalyzerForJvm.java | 34 +++++--- .../resolve/java/AnalyzerFacadeForJVM.java | 6 +- .../di/InjectorForTopDownAnalyzerBasic.java | 21 ++++- .../jet/lang/resolve/BodyResolver.java | 86 ++++++++++--------- .../jet/lang/resolve/ControlFlowAnalyzer.java | 10 ++- .../jet/lang/resolve/DeclarationResolver.java | 31 ++++--- .../jet/lang/resolve/DeclarationsChecker.java | 78 +++++++++-------- .../jet/lang/resolve/DelegationResolver.java | 14 ++- .../jet/lang/resolve/ImportsResolver.java | 15 +++- .../lang/resolve/NamespaceFactoryImpl.java | 22 ++--- .../jet/lang/resolve/OverloadResolver.java | 15 +++- .../jet/lang/resolve/OverrideResolver.java | 32 ++++--- .../lang/resolve/TopDownAnalysisContext.java | 8 -- .../resolve/TopDownAnalysisParameters.java | 11 +-- .../jet/lang/resolve/TopDownAnalyzer.java | 22 +++-- .../lang/resolve/TypeHierarchyResolver.java | 67 ++++++++------- .../jet/di/AllInjectorsGenerator.java | 2 +- 17 files changed, 278 insertions(+), 196 deletions(-) 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 44d0506476d..dbd5fa52d83 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -25,10 +25,10 @@ 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.resolve.java.JavaBridgeConfiguration; -import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -46,9 +46,9 @@ import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; 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.resolve.BindingTrace; import org.jetbrains.annotations.NotNull; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ @@ -62,15 +62,15 @@ public class InjectorForTopDownAnalyzerForJvm { private DescriptorResolver descriptorResolver; private final Project project; private final TopDownAnalysisParameters topDownAnalysisParameters; + private final ObservableBindingTrace observableBindingTrace; private JavaBridgeConfiguration javaBridgeConfiguration; - private final BindingTrace bindingTrace; public InjectorForTopDownAnalyzerForJvm( @NotNull Project project, @NotNull TopDownAnalysisParameters topDownAnalysisParameters, + @NotNull ObservableBindingTrace observableBindingTrace, @NotNull ModuleDescriptor moduleDescriptor, - JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory, - @NotNull BindingTrace bindingTrace + JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory ) { this.topDownAnalyzer = new TopDownAnalyzer(); this.topDownAnalysisContext = new TopDownAnalysisContext(); @@ -80,8 +80,8 @@ public class InjectorForTopDownAnalyzerForJvm { this.descriptorResolver = new DescriptorResolver(); this.project = project; this.topDownAnalysisParameters = topDownAnalysisParameters; + this.observableBindingTrace = observableBindingTrace; this.javaBridgeConfiguration = new JavaBridgeConfiguration(); - this.bindingTrace = bindingTrace; DeclarationResolver declarationResolver = new DeclarationResolver(); AnnotationResolver annotationResolver = new AnnotationResolver(); CallResolver callResolver = new CallResolver(); @@ -110,6 +110,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.topDownAnalyzer.setOverloadResolver(overloadResolver); this.topDownAnalyzer.setOverrideResolver(overrideResolver); this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters); + this.topDownAnalyzer.setTrace(observableBindingTrace); this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); this.topDownAnalysisContext.setTopDownAnalysisParameters(topDownAnalysisParameters); @@ -119,12 +120,15 @@ public class InjectorForTopDownAnalyzerForJvm { 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); @@ -137,6 +141,7 @@ public class InjectorForTopDownAnalyzerForJvm { declarationResolver.setContext(topDownAnalysisContext); declarationResolver.setDescriptorResolver(descriptorResolver); declarationResolver.setImportsResolver(importsResolver); + declarationResolver.setTrace(observableBindingTrace); annotationResolver.setCallResolver(callResolver); annotationResolver.setExpressionTypingServices(expressionTypingServices); @@ -156,25 +161,30 @@ public class InjectorForTopDownAnalyzerForJvm { importsResolver.setConfiguration(javaBridgeConfiguration); importsResolver.setContext(topDownAnalysisContext); + importsResolver.setTrace(observableBindingTrace); delegationResolver.setContext(topDownAnalysisContext); + delegationResolver.setTrace(observableBindingTrace); namespaceFactoryImpl.setConfiguration(javaBridgeConfiguration); - namespaceFactoryImpl.setContext(topDownAnalysisContext); 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); javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); - javaSemanticServices.setTrace(bindingTrace); + javaSemanticServices.setTrace(observableBindingTrace); javaSemanticServices.setTypeTransformer(javaTypeTransformer); javaDescriptorResolver.setProject(project); @@ -217,12 +227,12 @@ public class InjectorForTopDownAnalyzerForJvm { return this.topDownAnalysisParameters; } + public ObservableBindingTrace getObservableBindingTrace() { + return this.observableBindingTrace; + } + public JavaBridgeConfiguration getJavaBridgeConfiguration() { return this.javaBridgeConfiguration; } - public BindingTrace getBindingTrace() { - return this.bindingTrace; - } - } 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 5939de7a797..22e508835bd 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 @@ -37,6 +37,7 @@ import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; +import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import java.util.Collection; @@ -150,11 +151,12 @@ public class AnalyzerFacadeForJVM { final ModuleDescriptor owner = new ModuleDescriptor(""); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - filesToAnalyzeCompletely, false, false, bindingTraceContext); + filesToAnalyzeCompletely, false, false); InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm( - project, topDownAnalysisParameters, owner, flowDataTraceFactory, bindingTraceContext); + project, topDownAnalysisParameters, + new ObservableBindingTrace(bindingTraceContext), owner, flowDataTraceFactory); injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(files); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index e43fa83ea94..6f14e78f693 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -25,6 +25,7 @@ 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; @@ -42,6 +43,7 @@ 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; @@ -58,10 +60,12 @@ public class InjectorForTopDownAnalyzerBasic { private DescriptorResolver descriptorResolver; private final Project project; private final TopDownAnalysisParameters topDownAnalysisParameters; + private final ObservableBindingTrace observableBindingTrace; public InjectorForTopDownAnalyzerBasic( @NotNull Project project, @NotNull TopDownAnalysisParameters topDownAnalysisParameters, + @NotNull ObservableBindingTrace observableBindingTrace, @NotNull ModuleDescriptor moduleDescriptor, JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory, @NotNull ModuleConfiguration moduleConfiguration @@ -74,6 +78,7 @@ public class InjectorForTopDownAnalyzerBasic { 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(); @@ -99,6 +104,7 @@ public class InjectorForTopDownAnalyzerBasic { this.topDownAnalyzer.setOverloadResolver(overloadResolver); this.topDownAnalyzer.setOverrideResolver(overrideResolver); this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters); + this.topDownAnalyzer.setTrace(observableBindingTrace); this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); this.topDownAnalysisContext.setTopDownAnalysisParameters(topDownAnalysisParameters); @@ -108,12 +114,15 @@ public class InjectorForTopDownAnalyzerBasic { 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); @@ -123,6 +132,7 @@ public class InjectorForTopDownAnalyzerBasic { declarationResolver.setContext(topDownAnalysisContext); declarationResolver.setDescriptorResolver(descriptorResolver); declarationResolver.setImportsResolver(importsResolver); + declarationResolver.setTrace(observableBindingTrace); annotationResolver.setCallResolver(callResolver); annotationResolver.setExpressionTypingServices(expressionTypingServices); @@ -142,22 +152,27 @@ public class InjectorForTopDownAnalyzerBasic { importsResolver.setConfiguration(moduleConfiguration); importsResolver.setContext(topDownAnalysisContext); + importsResolver.setTrace(observableBindingTrace); delegationResolver.setContext(topDownAnalysisContext); + delegationResolver.setTrace(observableBindingTrace); namespaceFactoryImpl.setConfiguration(moduleConfiguration); - namespaceFactoryImpl.setContext(topDownAnalysisContext); 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); } @@ -193,4 +208,8 @@ public class InjectorForTopDownAnalyzerBasic { return this.topDownAnalysisParameters; } + public ObservableBindingTrace getObservableBindingTrace() { + return this.observableBindingTrace; + } + } 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 d58bb5051a2..d109570fa7d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java @@ -62,6 +62,8 @@ public class BodyResolver { private ExpressionTypingServices expressionTypingServices; @NotNull private CallResolver callResolver; + @NotNull + private ObservableBindingTrace trace; @Inject @@ -89,6 +91,10 @@ public class BodyResolver { this.callResolver = callResolver; } + @Inject + public void setTrace(@NotNull ObservableBindingTrace trace) { + this.trace = trace; + } @@ -124,7 +130,7 @@ public class BodyResolver { final ConstructorDescriptor primaryConstructor = descriptor.getUnsubstitutedPrimaryConstructor(); final JetScope scopeForConstructor = primaryConstructor == null ? null - : FunctionDescriptorUtil.getFunctionInnerScope(descriptor.getScopeForSupertypeResolution(), primaryConstructor, context.getTrace()); + : FunctionDescriptorUtil.getFunctionInnerScope(descriptor.getScopeForSupertypeResolution(), primaryConstructor, trace); final ExpressionTypingServices typeInferrer = expressionTypingServices; // TODO : flow final Map supertypes = Maps.newLinkedHashMap(); @@ -137,16 +143,16 @@ public class BodyResolver { @Override public void visitDelegationByExpressionSpecifier(JetDelegatorByExpressionSpecifier specifier) { if (descriptor.getKind() == ClassKind.TRAIT) { - context.getTrace().report(DELEGATION_IN_TRAIT.on(specifier)); + trace.report(DELEGATION_IN_TRAIT.on(specifier)); } - JetType supertype = context.getTrace().getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference()); + JetType supertype = trace.getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference()); recordSupertype(specifier.getTypeReference(), supertype); if (supertype != null) { DeclarationDescriptor declarationDescriptor = supertype.getConstructor().getDeclarationDescriptor(); if (declarationDescriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor; if (classDescriptor.getKind() != ClassKind.TRAIT) { - context.getTrace().report(DELEGATION_NOT_TO_TRAIT.on(specifier.getTypeReference())); + trace.report(DELEGATION_NOT_TO_TRAIT.on(specifier.getTypeReference())); } } } @@ -155,9 +161,9 @@ public class BodyResolver { JetScope scope = scopeForConstructor == null ? descriptor.getScopeForMemberResolution() : scopeForConstructor; - JetType type = typeInferrer.getType(scope, delegateExpression, NO_EXPECTED_TYPE, context.getTrace()); + JetType type = typeInferrer.getType(scope, delegateExpression, NO_EXPECTED_TYPE, trace); if (type != null && supertype != null && !JetTypeChecker.INSTANCE.isSubtypeOf(type, supertype)) { - context.getTrace().report(TYPE_MISMATCH.on(delegateExpression, supertype, type)); + trace.report(TYPE_MISMATCH.on(delegateExpression, supertype, type)); } } } @@ -167,7 +173,7 @@ public class BodyResolver { JetValueArgumentList valueArgumentList = call.getValueArgumentList(); PsiElement elementToMark = valueArgumentList == null ? call : valueArgumentList; if (descriptor.getKind() == ClassKind.TRAIT) { - context.getTrace().report(SUPERTYPE_INITIALIZED_IN_TRAIT.on(elementToMark)); + trace.report(SUPERTYPE_INITIALIZED_IN_TRAIT.on(elementToMark)); } JetTypeReference typeReference = call.getTypeReference(); if (typeReference == null) return; @@ -176,7 +182,7 @@ public class BodyResolver { return; } OverloadResolutionResults results = callResolver.resolveFunctionCall( - context.getTrace(), scopeForConstructor, + trace, scopeForConstructor, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, DataFlowInfo.EMPTY); if (results.isSuccess()) { JetType supertype = results.getResultingDescriptor().getReturnType(); @@ -184,19 +190,19 @@ public class BodyResolver { ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype); if (classDescriptor != null) { if (classDescriptor.getKind() == ClassKind.TRAIT) { - context.getTrace().report(CONSTRUCTOR_IN_TRAIT.on(elementToMark)); + trace.report(CONSTRUCTOR_IN_TRAIT.on(elementToMark)); } } } else { - recordSupertype(typeReference, context.getTrace().getBindingContext().get(BindingContext.TYPE, typeReference)); + recordSupertype(typeReference, trace.getBindingContext().get(BindingContext.TYPE, typeReference)); } } @Override public void visitDelegationToSuperClassSpecifier(JetDelegatorToSuperClass specifier) { JetTypeReference typeReference = specifier.getTypeReference(); - JetType supertype = context.getTrace().getBindingContext().get(BindingContext.TYPE, typeReference); + JetType supertype = trace.getBindingContext().get(BindingContext.TYPE, typeReference); recordSupertype(typeReference, supertype); if (supertype == null) return; ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype); @@ -210,10 +216,10 @@ public class BodyResolver { } } if (!hasConstructorWithoutParams) { - context.getTrace().report(SUPERTYPE_NOT_INITIALIZED.on(specifier)); + trace.report(SUPERTYPE_NOT_INITIALIZED.on(specifier)); } else { - context.getTrace().report(SUPERTYPE_NOT_INITIALIZED_DEFAULT.on(specifier)); + trace.report(SUPERTYPE_NOT_INITIALIZED_DEFAULT.on(specifier)); } } } @@ -254,7 +260,7 @@ public class BodyResolver { if (classDescriptor != null) { if (classDescriptor.getKind() != ClassKind.TRAIT) { if (classAppeared) { - context.getTrace().report(MANY_CLASSES_IN_SUPERTYPE_LIST.on(typeReference)); + trace.report(MANY_CLASSES_IN_SUPERTYPE_LIST.on(typeReference)); } else { classAppeared = true; @@ -262,16 +268,16 @@ public class BodyResolver { } } else { - context.getTrace().report(SUPERTYPE_NOT_A_CLASS_OR_TRAIT.on(typeReference)); + trace.report(SUPERTYPE_NOT_A_CLASS_OR_TRAIT.on(typeReference)); } TypeConstructor constructor = supertype.getConstructor(); if (!typeConstructors.add(constructor)) { - context.getTrace().report(SUPERTYPE_APPEARS_TWICE.on(typeReference)); + trace.report(SUPERTYPE_APPEARS_TWICE.on(typeReference)); } if (constructor.isSealed() && !allowedFinalSupertypes.contains(constructor)) { - context.getTrace().report(FINAL_SUPERTYPE.on(typeReference)); + trace.report(FINAL_SUPERTYPE.on(typeReference)); } } } @@ -296,12 +302,12 @@ public class BodyResolver { assert primaryConstructor != null; final JetScope scopeForInitializers = classDescriptor.getScopeForInitializers(); for (JetClassInitializer anonymousInitializer : anonymousInitializers) { - expressionTypingServices.getType(scopeForInitializers, anonymousInitializer.getBody(), NO_EXPECTED_TYPE, context.getTrace()); + expressionTypingServices.getType(scopeForInitializers, anonymousInitializer.getBody(), NO_EXPECTED_TYPE, trace); } } else { for (JetClassInitializer anonymousInitializer : anonymousInitializers) { - context.getTrace().report(ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR.on(anonymousInitializer)); + trace.report(ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR.on(anonymousInitializer)); } } } @@ -331,21 +337,21 @@ public class BodyResolver { private void resolveSecondaryConstructorBody(JetSecondaryConstructor declaration, final ConstructorDescriptor descriptor) { if (!context.completeAnalysisNeeded(declaration)) return; MutableClassDescriptor classDescriptor = (MutableClassDescriptor) descriptor.getContainingDeclaration(); - final JetScope scopeForSupertypeInitializers = FunctionDescriptorUtil.getFunctionInnerScope(classDescriptor.getScopeForSupertypeResolution(), descriptor, context.getTrace()); + final JetScope scopeForSupertypeInitializers = FunctionDescriptorUtil.getFunctionInnerScope(classDescriptor.getScopeForSupertypeResolution(), descriptor, trace); //contains only constructor parameters - final JetScope scopeForConstructorBody = FunctionDescriptorUtil.getFunctionInnerScope(classDescriptor.getScopeForInitializers(), descriptor, context.getTrace()); + final JetScope scopeForConstructorBody = FunctionDescriptorUtil.getFunctionInnerScope(classDescriptor.getScopeForInitializers(), descriptor, trace); //contains members & backing fields final DataFlowInfo dataFlowInfo = DataFlowInfo.EMPTY; // TODO: dataFlowInfo PsiElement nameElement = declaration.getNameNode().getPsi(); if (classDescriptor.getUnsubstitutedPrimaryConstructor() == null) { - context.getTrace().report(SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY.on(nameElement)); + trace.report(SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY.on(nameElement)); } else { List initializers = declaration.getInitializers(); if (initializers.isEmpty()) { - context.getTrace().report(SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST.on(nameElement)); + trace.report(SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST.on(nameElement)); } else { initializers.get(0).accept(new JetVisitorVoid() { @@ -353,7 +359,7 @@ public class BodyResolver { public void visitDelegationToSuperCallSpecifier(JetDelegatorToSuperCall call) { JetTypeReference typeReference = call.getTypeReference(); if (typeReference != null) { - callResolver.resolveFunctionCall(context.getTrace(), scopeForSupertypeInitializers, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, dataFlowInfo); + callResolver.resolveFunctionCall(trace, scopeForSupertypeInitializers, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, dataFlowInfo); } } @@ -363,24 +369,24 @@ public class BodyResolver { // TODO : check: if a this() call is present, no other initializers are allowed ClassDescriptor classDescriptor = descriptor.getContainingDeclaration(); - callResolver.resolveFunctionCall(context.getTrace(), + callResolver.resolveFunctionCall(trace, scopeForSupertypeInitializers, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, dataFlowInfo); // call.getThisReference(), // classDescriptor, // classDescriptor.getDefaultType(), // call); -// context.getTrace().getErrorHandler().genericError(call.getNode(), "this-calls are not supported"); +// trace.getErrorHandler().genericError(call.getNode(), "this-calls are not supported"); } @Override public void visitDelegationByExpressionSpecifier(JetDelegatorByExpressionSpecifier specifier) { - context.getTrace().report(BY_IN_SECONDARY_CONSTRUCTOR.on(specifier)); + trace.report(BY_IN_SECONDARY_CONSTRUCTOR.on(specifier)); } @Override public void visitDelegationToSuperClassSpecifier(JetDelegatorToSuperClass specifier) { - context.getTrace().report(INITIALIZER_WITH_NO_ARGUMENTS.on(specifier)); + trace.report(INITIALIZER_WITH_NO_ARGUMENTS.on(specifier)); } @Override @@ -390,14 +396,14 @@ public class BodyResolver { }); for (int i = 1, initializersSize = initializers.size(); i < initializersSize; i++) { JetDelegationSpecifier initializer = initializers.get(i); - context.getTrace().report(MANY_CALLS_TO_THIS.on(initializer)); + trace.report(MANY_CALLS_TO_THIS.on(initializer)); } } } JetExpression bodyExpression = declaration.getBodyExpression(); if (bodyExpression != null) { - expressionTypingServices.checkFunctionReturnType(scopeForConstructorBody, declaration, descriptor, JetStandardClasses.getUnitType(), context.getTrace()); + expressionTypingServices.checkFunctionReturnType(scopeForConstructorBody, declaration, descriptor, JetStandardClasses.getUnitType(), trace); } checkDefaultParameterValues(declaration.getValueParameters(), descriptor.getValueParameters(), scopeForConstructorBody); @@ -457,8 +463,8 @@ public class BodyResolver { JetScope declaringScope = context.getDeclaringScopes().get(accessor); JetScope propertyDeclarationInnerScope = descriptorResolver.getPropertyDeclarationInnerScope( - declaringScope, propertyDescriptor, propertyDescriptor.getTypeParameters(), propertyDescriptor.getReceiverParameter(), context.getTrace()); - WritableScope accessorScope = new WritableScopeImpl(propertyDeclarationInnerScope, declaringScope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Accessor scope"); + declaringScope, propertyDescriptor, propertyDescriptor.getTypeParameters(), propertyDescriptor.getReceiverParameter(), trace); + WritableScope accessorScope = new WritableScopeImpl(propertyDeclarationInnerScope, declaringScope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(trace)).setDebugName("Accessor scope"); accessorScope.changeLockLevel(WritableScope.LockLevel.READING); return accessorScope; @@ -483,7 +489,7 @@ public class BodyResolver { } private ObservableBindingTrace createFieldTrackingTrace(final PropertyDescriptor propertyDescriptor) { - return new ObservableBindingTrace(context.getTrace()).addHandler(BindingContext.REFERENCE_TARGET, new ObservableBindingTrace.RecordHandler() { + return new ObservableBindingTrace(trace).addHandler(BindingContext.REFERENCE_TARGET, new ObservableBindingTrace.RecordHandler() { @Override public void handleRecord(WritableSlice slice, JetReferenceExpression expression, DeclarationDescriptor descriptor) { if (expression instanceof JetSimpleNameExpression) { @@ -491,7 +497,7 @@ public class BodyResolver { if (simpleNameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) { // This check may be considered redundant as long as $x is only accessible from accessors to $x if (descriptor == propertyDescriptor) { // TODO : original? - context.getTrace().record(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor); // TODO: this context.getTrace()? + trace.record(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor); // TODO: this trace? } } } @@ -502,7 +508,7 @@ public class BodyResolver { private void resolvePropertyInitializer(JetProperty property, PropertyDescriptor propertyDescriptor, JetExpression initializer, JetScope scope) { //JetFlowInformationProvider flowInformationProvider = context.getDescriptorResolver().computeFlowData(property, initializer); // TODO : flow JET-15 JetType expectedTypeForInitializer = property.getPropertyTypeRef() != null ? propertyDescriptor.getType() : NO_EXPECTED_TYPE; - JetType type = expressionTypingServices.getType(descriptorResolver.getPropertyDeclarationInnerScope(scope, propertyDescriptor, propertyDescriptor.getTypeParameters(), propertyDescriptor.getReceiverParameter(), context.getTrace()), initializer, expectedTypeForInitializer, context.getTrace()); + JetType type = expressionTypingServices.getType(descriptorResolver.getPropertyDeclarationInnerScope(scope, propertyDescriptor, propertyDescriptor.getTypeParameters(), propertyDescriptor.getReceiverParameter(), trace), initializer, expectedTypeForInitializer, trace); // // JetType expectedType = propertyDescriptor.getInType(); // if (expectedType == null) { @@ -510,7 +516,7 @@ public class BodyResolver { // } // if (type != null && expectedType != null // && !context.getSemanticServices().getTypeChecker().isSubtypeOf(type, expectedType)) { -//// context.getTrace().report(TYPE_MISMATCH.on(initializer, expectedType, type)); +//// trace.report(TYPE_MISMATCH.on(initializer, expectedType, type)); // } } @@ -524,7 +530,7 @@ public class BodyResolver { JetScope declaringScope = this.context.getDeclaringScopes().get(declaration); assert declaringScope != null; - resolveFunctionBody(context.getTrace(), declaration, descriptor, declaringScope); + resolveFunctionBody(trace, declaration, descriptor, declaringScope); assert descriptor.getReturnType() != null; } @@ -558,7 +564,7 @@ public class BodyResolver { JetParameter jetParameter = valueParameters.get(i); JetExpression defaultValue = jetParameter.getDefaultValue(); if (defaultValue != null) { - expressionTypingServices.getType(declaringScope, defaultValue, valueParameterDescriptor.getType(), context.getTrace()); + expressionTypingServices.getType(declaringScope, defaultValue, valueParameterDescriptor.getType(), trace); } } } @@ -578,11 +584,11 @@ public class BodyResolver { } private void computeDeferredTypes() { - Collection> deferredTypes = context.getTrace().getKeys(DEFERRED_TYPE); + Collection> deferredTypes = trace.getKeys(DEFERRED_TYPE); if (deferredTypes != null) { // +1 is a work around agains new Queue(0).addLast(...) bug // stepan.koltsov@ 2011-11-21 final Queue queue = new Queue(deferredTypes.size() + 1); - context.getTrace().addHandler(DEFERRED_TYPE, new ObservableBindingTrace.RecordHandler, Boolean>() { + trace.addHandler(DEFERRED_TYPE, new ObservableBindingTrace.RecordHandler, Boolean>() { @Override public void handleRecord(WritableSlice, Boolean> deferredTypeKeyDeferredTypeWritableSlice, Box key, Boolean value) { queue.addLast(key.getData()); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java index 73ff41c9d91..9805e04b7ca 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java @@ -37,6 +37,7 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; public class ControlFlowAnalyzer { private TopDownAnalysisParameters topDownAnalysisParameters; private TopDownAnalysisContext context; + private BindingTrace trace; private JetControlFlowDataTraceFactory flowDataTraceFactory; @@ -50,6 +51,11 @@ public class ControlFlowAnalyzer { this.context = context; } + @Inject + public void setTrace(BindingTrace trace) { + this.trace = trace; + } + @Inject public void setFlowDataTraceFactory(JetControlFlowDataTraceFactory flowDataTraceFactory) { this.flowDataTraceFactory = flowDataTraceFactory; @@ -88,7 +94,7 @@ public class ControlFlowAnalyzer { private void checkClassOrObject(JetClassOrObject klass) { // A pseudocode of class initialization corresponds to a class - JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider((JetDeclaration) klass, (JetExpression) klass, flowDataTraceFactory, context.getTrace()); + JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider((JetDeclaration) klass, (JetExpression) klass, flowDataTraceFactory, trace); flowInformationProvider.markUninitializedVariables((JetElement) klass, topDownAnalysisParameters.isDeclaredLocally()); } @@ -107,7 +113,7 @@ public class ControlFlowAnalyzer { JetExpression bodyExpression = function.getBodyExpression(); if (bodyExpression == null) return; - JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider((JetDeclaration) function, bodyExpression, flowDataTraceFactory, context.getTrace()); + JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider((JetDeclaration) function, bodyExpression, flowDataTraceFactory, trace); flowInformationProvider.checkDefiniteReturn(function, expectedReturnType); 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 1a988c0ea5e..5fc3ca3008e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java @@ -40,6 +40,8 @@ public class DeclarationResolver { private ImportsResolver importsResolver; @NotNull private DescriptorResolver descriptorResolver; + @NotNull + private BindingTrace trace; @Inject @@ -62,6 +64,11 @@ public class DeclarationResolver { this.descriptorResolver = descriptorResolver; } + @Inject + public void setTrace(@NotNull BindingTrace trace) { + this.trace = trace; + } + public void process() { @@ -99,7 +106,7 @@ public class DeclarationResolver { private void resolveAnnotationsForClassOrObject(AnnotationResolver annotationResolver, JetClassOrObject jetClass, MutableClassDescriptor descriptor) { JetModifierList modifierList = jetClass.getModifierList(); if (modifierList != null) { - descriptor.getAnnotations().addAll(annotationResolver.resolveAnnotations(descriptor.getScopeForSupertypeResolution(), modifierList.getAnnotationEntries(), context.getTrace())); + descriptor.getAnnotations().addAll(annotationResolver.resolveAnnotations(descriptor.getScopeForSupertypeResolution(), modifierList.getAnnotationEntries(), trace)); } } @@ -144,7 +151,7 @@ public class DeclarationResolver { declaration.accept(new JetVisitorVoid() { @Override public void visitNamedFunction(JetNamedFunction function) { - SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(namespaceLike.getOwnerForChildren(), scopeForFunctions, function, context.getTrace()); + SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(namespaceLike.getOwnerForChildren(), scopeForFunctions, function, trace); namespaceLike.addFunctionDescriptor(functionDescriptor); context.getFunctions().put(function, functionDescriptor); context.getDeclaringScopes().put(function, scopeForFunctions); @@ -152,7 +159,7 @@ public class DeclarationResolver { @Override public void visitProperty(JetProperty property) { - PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(namespaceLike.getOwnerForChildren(), scopeForPropertyInitializers, property, context.getTrace()); + PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(namespaceLike.getOwnerForChildren(), scopeForPropertyInitializers, property, trace); namespaceLike.addPropertyDescriptor(propertyDescriptor); context.getProperties().put(property, propertyDescriptor); context.getDeclaringScopes().put(property, scopeForPropertyInitializers); @@ -166,7 +173,7 @@ public class DeclarationResolver { @Override public void visitObjectDeclaration(JetObjectDeclaration declaration) { - PropertyDescriptor propertyDescriptor = descriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(namespaceLike.getOwnerForChildren(), declaration, context.getObjects().get(declaration), context.getTrace()); + PropertyDescriptor propertyDescriptor = descriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(namespaceLike.getOwnerForChildren(), declaration, context.getObjects().get(declaration), trace); namespaceLike.addPropertyDescriptor(propertyDescriptor); } @@ -175,7 +182,7 @@ public class DeclarationResolver { if (enumEntry.getPrimaryConstructorParameterList() == null) { MutableClassDescriptorLite classObjectDescriptor = ((MutableClassDescriptor) namespaceLike).getClassObjectDescriptor(); assert classObjectDescriptor != null; - PropertyDescriptor propertyDescriptor = descriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(classObjectDescriptor, enumEntry, context.getClasses().get(enumEntry), context.getTrace()); + PropertyDescriptor propertyDescriptor = descriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(classObjectDescriptor, enumEntry, context.getClasses().get(enumEntry), trace); classObjectDescriptor.addPropertyDescriptor(propertyDescriptor); } } @@ -187,39 +194,39 @@ public class DeclarationResolver { if (classDescriptor.getKind() == ClassKind.TRAIT) { JetParameterList primaryConstructorParameterList = klass.getPrimaryConstructorParameterList(); if (primaryConstructorParameterList != null) { - context.getTrace().report(CONSTRUCTOR_IN_TRAIT.on(primaryConstructorParameterList)); + trace.report(CONSTRUCTOR_IN_TRAIT.on(primaryConstructorParameterList)); } if (!klass.hasPrimaryConstructor()) return; } // TODO : not all the parameters are real properties JetScope memberScope = classDescriptor.getScopeForSupertypeResolution(); - ConstructorDescriptor constructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass, context.getTrace()); + ConstructorDescriptor constructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass, trace); for (JetParameter parameter : klass.getPrimaryConstructorParameters()) { if (parameter.getValOrVarNode() != null) { PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePrimaryConstructorParameterToAProperty( classDescriptor, memberScope, - parameter, context.getTrace() + parameter, trace ); classDescriptor.addPropertyDescriptor(propertyDescriptor); context.getPrimaryConstructorParameterProperties().add(propertyDescriptor); } } if (constructorDescriptor != null) { - classDescriptor.setPrimaryConstructor(constructorDescriptor, context.getTrace()); + classDescriptor.setPrimaryConstructor(constructorDescriptor, trace); } } private void processSecondaryConstructor(MutableClassDescriptor classDescriptor, JetSecondaryConstructor constructor) { if (classDescriptor.getKind() == ClassKind.TRAIT) { - context.getTrace().report(CONSTRUCTOR_IN_TRAIT.on(constructor.getNameNode().getPsi())); + trace.report(CONSTRUCTOR_IN_TRAIT.on(constructor.getNameNode().getPsi())); } ConstructorDescriptor constructorDescriptor = descriptorResolver.resolveSecondaryConstructorDescriptor( classDescriptor.getScopeForMemberResolution(), classDescriptor, - constructor, context.getTrace()); - classDescriptor.addConstructor(constructorDescriptor, context.getTrace()); + constructor, trace); + classDescriptor.addConstructor(constructorDescriptor, trace); context.getConstructors().put(constructor, constructorDescriptor); context.getDeclaringScopes().put(constructor, classDescriptor.getScopeForMemberLookup()); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java index b9dbd071704..a22e1a3c974 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java @@ -47,6 +47,8 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.TYPE; public class DeclarationsChecker { @NotNull private TopDownAnalysisContext context; + @NotNull + private BindingTrace trace; @Inject @@ -54,6 +56,12 @@ public class DeclarationsChecker { this.context = context; } + @Inject + public void setTrace(@NotNull BindingTrace trace) { + this.trace = trace; + } + + public void process() { Map classes = context.getClasses(); @@ -108,13 +116,13 @@ public class DeclarationsChecker { JetModifierList modifierList = aClass.getModifierList(); if (modifierList == null) return; if (modifierList.hasModifier(JetTokens.FINAL_KEYWORD)) { - context.getTrace().report(Errors.TRAIT_CAN_NOT_BE_FINAL.on(modifierList.getModifierNode(JetTokens.FINAL_KEYWORD).getPsi())); + trace.report(Errors.TRAIT_CAN_NOT_BE_FINAL.on(modifierList.getModifierNode(JetTokens.FINAL_KEYWORD).getPsi())); } if (modifierList.hasModifier(JetTokens.ABSTRACT_KEYWORD)) { - context.getTrace().report(Errors.ABSTRACT_MODIFIER_IN_TRAIT.on(aClass)); + trace.report(Errors.ABSTRACT_MODIFIER_IN_TRAIT.on(aClass)); } if (modifierList.hasModifier(JetTokens.OPEN_KEYWORD)) { - context.getTrace().report(Errors.OPEN_MODIFIER_IN_TRAIT.on(aClass)); + trace.report(Errors.OPEN_MODIFIER_IN_TRAIT.on(aClass)); } } @@ -126,9 +134,9 @@ public class DeclarationsChecker { private void checkOpenMembers(MutableClassDescriptor classDescriptor) { for (CallableMemberDescriptor memberDescriptor : classDescriptor.getCallableMembers()) { - JetNamedDeclaration member = (JetNamedDeclaration) context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, memberDescriptor); + JetNamedDeclaration member = (JetNamedDeclaration) trace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, memberDescriptor); if (member != null && classDescriptor.getModality() == Modality.FINAL && member.hasModifier(JetTokens.OPEN_KEYWORD)) { - context.getTrace().report(NON_FINAL_MEMBER_IN_FINAL_CLASS.on(member)); + trace.report(NON_FINAL_MEMBER_IN_FINAL_CLASS.on(member)); } } } @@ -155,7 +163,7 @@ public class DeclarationsChecker { hasDeferredType = function.getReturnTypeRef() == null && function.getBodyExpression() != null && !function.hasBlockBody(); } if ((memberDescriptor.getVisibility() == Visibility.PUBLIC || memberDescriptor.getVisibility() == Visibility.PROTECTED) && hasDeferredType) { - context.getTrace().report(PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE.on(member)); + trace.report(PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE.on(member)); } } @@ -167,18 +175,18 @@ public class DeclarationsChecker { if (abstractNode != null) { //has abstract modifier if (classDescriptor == null) { - context.getTrace().report(ABSTRACT_PROPERTY_NOT_IN_CLASS.on(property)); + trace.report(ABSTRACT_PROPERTY_NOT_IN_CLASS.on(property)); return; } if (!(classDescriptor.getModality() == Modality.ABSTRACT) && classDescriptor.getKind() != ClassKind.ENUM_CLASS) { - PsiElement classElement = context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, classDescriptor); + PsiElement classElement = trace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, classDescriptor); assert classElement instanceof JetClass; String name = property.getName(); - context.getTrace().report(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.on(property, name != null ? name : "", classDescriptor, (JetClass) classElement)); + trace.report(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.on(property, name != null ? name : "", classDescriptor, (JetClass) classElement)); return; } if (classDescriptor.getKind() == ClassKind.TRAIT) { - context.getTrace().report(ABSTRACT_MODIFIER_IN_TRAIT.on(property)); + trace.report(ABSTRACT_MODIFIER_IN_TRAIT.on(property)); } } @@ -190,13 +198,13 @@ public class DeclarationsChecker { JetExpression initializer = property.getInitializer(); if (initializer != null) { - context.getTrace().report(ABSTRACT_PROPERTY_WITH_INITIALIZER.on(initializer)); + trace.report(ABSTRACT_PROPERTY_WITH_INITIALIZER.on(initializer)); } if (getter != null && getter.getBodyExpression() != null) { - context.getTrace().report(ABSTRACT_PROPERTY_WITH_GETTER.on(getter)); + trace.report(ABSTRACT_PROPERTY_WITH_GETTER.on(getter)); } if (setter != null && setter.getBodyExpression() != null) { - context.getTrace().report(ABSTRACT_PROPERTY_WITH_SETTER.on(setter)); + trace.report(ABSTRACT_PROPERTY_WITH_SETTER.on(setter)); } } } @@ -210,27 +218,27 @@ public class DeclarationsChecker { boolean inTrait = classDescriptor != null && classDescriptor.getKind() == ClassKind.TRAIT; JetExpression initializer = property.getInitializer(); - boolean backingFieldRequired = context.getTrace().getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor); + boolean backingFieldRequired = trace.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor); if (inTrait && backingFieldRequired && hasAccessorImplementation) { - context.getTrace().report(BACKING_FIELD_IN_TRAIT.on(property)); + trace.report(BACKING_FIELD_IN_TRAIT.on(property)); } if (initializer == null) { - if (backingFieldRequired && !inTrait && !context.getTrace().getBindingContext().get(BindingContext.IS_INITIALIZED, propertyDescriptor)) { + if (backingFieldRequired && !inTrait && !trace.getBindingContext().get(BindingContext.IS_INITIALIZED, propertyDescriptor)) { if (classDescriptor == null || hasAccessorImplementation) { - context.getTrace().report(MUST_BE_INITIALIZED.on(property)); + trace.report(MUST_BE_INITIALIZED.on(property)); } else { - context.getTrace().report(MUST_BE_INITIALIZED_OR_BE_ABSTRACT.on(property)); + trace.report(MUST_BE_INITIALIZED_OR_BE_ABSTRACT.on(property)); } } return; } if (inTrait) { - context.getTrace().report(PROPERTY_INITIALIZER_IN_TRAIT.on(initializer)); + trace.report(PROPERTY_INITIALIZER_IN_TRAIT.on(initializer)); } else if (!backingFieldRequired) { - context.getTrace().report(PROPERTY_INITIALIZER_NO_BACKING_FIELD.on(initializer)); + trace.report(PROPERTY_INITIALIZER_NO_BACKING_FIELD.on(initializer)); } } @@ -244,26 +252,26 @@ public class DeclarationsChecker { boolean inEnum = classDescriptor.getKind() == ClassKind.ENUM_CLASS; boolean inAbstractClass = classDescriptor.getModality() == Modality.ABSTRACT; if (hasAbstractModifier && !inAbstractClass && !inTrait && !inEnum) { - PsiElement classElement = context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, classDescriptor); + PsiElement classElement = trace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, classDescriptor); assert classElement instanceof JetClass; - context.getTrace().report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(function, functionDescriptor.getName(), classDescriptor, (JetClass) classElement)); + trace.report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(function, functionDescriptor.getName(), classDescriptor, (JetClass) classElement)); } if (hasAbstractModifier && inTrait) { - context.getTrace().report(ABSTRACT_MODIFIER_IN_TRAIT.on(function)); + trace.report(ABSTRACT_MODIFIER_IN_TRAIT.on(function)); } if (function.getBodyExpression() != null && hasAbstractModifier) { - context.getTrace().report(ABSTRACT_FUNCTION_WITH_BODY.on(function, functionDescriptor)); + trace.report(ABSTRACT_FUNCTION_WITH_BODY.on(function, functionDescriptor)); } if (function.getBodyExpression() == null && !hasAbstractModifier && !inTrait) { - context.getTrace().report(NON_ABSTRACT_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor)); + trace.report(NON_ABSTRACT_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor)); } return; } if (hasAbstractModifier) { - context.getTrace().report(NON_MEMBER_ABSTRACT_FUNCTION.on(function, functionDescriptor)); + trace.report(NON_MEMBER_ABSTRACT_FUNCTION.on(function, functionDescriptor)); } if (function.getBodyExpression() == null && !hasAbstractModifier) { - context.getTrace().report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor)); + trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor)); } } @@ -278,12 +286,12 @@ public class DeclarationsChecker { Map nodes = getNodesCorrespondingToModifiers(getterModifierList, Sets.newHashSet(JetTokens.PUBLIC_KEYWORD, JetTokens.PROTECTED_KEYWORD, JetTokens.PRIVATE_KEYWORD, JetTokens.INTERNAL_KEYWORD)); if (getterDescriptor.getVisibility() != propertyDescriptor.getVisibility()) { for (ASTNode node : nodes.values()) { - context.getTrace().report(Errors.GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY.on(node.getPsi())); + trace.report(Errors.GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY.on(node.getPsi())); } } else { for (ASTNode node : nodes.values()) { - context.getTrace().report(Errors.REDUNDANT_MODIFIER_IN_GETTER.on(node.getPsi())); + trace.report(Errors.REDUNDANT_MODIFIER_IN_GETTER.on(node.getPsi())); } } } @@ -326,7 +334,7 @@ public class DeclarationsChecker { } } for (JetKeywordToken token : presentModifiers) { - context.getTrace().report(Errors.INCOMPATIBLE_MODIFIERS.on(modifierList.getModifierNode(token).getPsi(), presentModifiers)); + trace.report(Errors.INCOMPATIBLE_MODIFIERS.on(modifierList.getModifierNode(token).getPsi(), presentModifiers)); } } @@ -335,7 +343,7 @@ public class DeclarationsChecker { JetKeywordToken redundantModifier = tokenPair.getFirst(); JetKeywordToken sufficientModifier = tokenPair.getSecond(); if (modifierList.hasModifier(redundantModifier) && modifierList.hasModifier(sufficientModifier)) { - context.getTrace().report(Errors.REDUNDANT_MODIFIER.on(modifierList.getModifierNode(redundantModifier).getPsi(), redundantModifier, sufficientModifier)); + trace.report(Errors.REDUNDANT_MODIFIER.on(modifierList.getModifierNode(redundantModifier).getPsi(), redundantModifier, sufficientModifier)); } } } @@ -344,7 +352,7 @@ public class DeclarationsChecker { if (modifierList == null) return; for (JetKeywordToken modifier : illegalModifiers) { if (modifierList.hasModifier(modifier)) { - context.getTrace().report(Errors.ILLEGAL_MODIFIER.on(modifierList.getModifierNode(modifier).getPsi(), modifier)); + trace.report(Errors.ILLEGAL_MODIFIER.on(modifierList.getModifierNode(modifier).getPsi(), modifier)); } } } @@ -372,17 +380,17 @@ public class DeclarationsChecker { ConstructorDescriptor constructor = enumClass.getUnsubstitutedPrimaryConstructor(); assert constructor != null; if (!constructor.getValueParameters().isEmpty() && delegationSpecifiers.isEmpty()) { - context.getTrace().report(ENUM_ENTRY_SHOULD_BE_INITIALIZED.on(aClass, enumClass)); + trace.report(ENUM_ENTRY_SHOULD_BE_INITIALIZED.on(aClass, enumClass)); } for (JetDelegationSpecifier delegationSpecifier : delegationSpecifiers) { JetTypeReference typeReference = delegationSpecifier.getTypeReference(); if (typeReference != null) { - JetType type = context.getTrace().getBindingContext().get(TYPE, typeReference); + JetType type = trace.getBindingContext().get(TYPE, typeReference); if (type != null) { JetType enumType = enumClass.getDefaultType(); if (!type.getConstructor().equals(enumType.getConstructor())) { - context.getTrace().report(ENUM_ENTRY_ILLEGAL_TYPE.on(typeReference, enumClass)); + trace.report(ENUM_ENTRY_ILLEGAL_TYPE.on(typeReference, enumClass)); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java index 730b80bd1cd..102cf6f271e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java @@ -32,6 +32,8 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED; public class DelegationResolver { @NotNull private TopDownAnalysisContext context; + @NotNull + private BindingTrace trace; @Inject @@ -39,6 +41,12 @@ public class DelegationResolver { this.context = context; } + @Inject + public void setTrace(@NotNull BindingTrace trace) { + this.trace = trace; + } + + public void process() { addDelegatedMembers(); @@ -57,7 +65,7 @@ public class DelegationResolver { for (JetDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) { if (delegationSpecifier instanceof JetDelegatorByExpressionSpecifier) { JetDelegatorByExpressionSpecifier specifier = (JetDelegatorByExpressionSpecifier) delegationSpecifier; - JetType type = context.getTrace().get(BindingContext.TYPE, specifier.getTypeReference()); + JetType type = trace.get(BindingContext.TYPE, specifier.getTypeReference()); if (type != null) { for (DeclarationDescriptor declarationDescriptor : type.getMemberScope().getAllDescriptors()) { if (declarationDescriptor instanceof PropertyDescriptor) { @@ -65,7 +73,7 @@ public class DelegationResolver { if (propertyDescriptor.getModality().isOverridable()) { PropertyDescriptor copy = propertyDescriptor.copy(classDescriptor, true, CallableMemberDescriptor.Kind.DELEGATION, true); classDescriptor.addPropertyDescriptor(copy); - context.getTrace().record(DELEGATED, copy); + trace.record(DELEGATED, copy); } } else if (declarationDescriptor instanceof SimpleFunctionDescriptor) { @@ -73,7 +81,7 @@ public class DelegationResolver { if (functionDescriptor.getModality().isOverridable()) { SimpleFunctionDescriptor copy = functionDescriptor.copy(classDescriptor, true, CallableMemberDescriptor.Kind.DELEGATION, true); classDescriptor.addFunctionDescriptor(copy); - context.getTrace().record(DELEGATED, copy); + trace.record(DELEGATED, copy); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index 098a028ddae..241474e51cb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -45,6 +45,8 @@ public class ImportsResolver { private ModuleConfiguration configuration; @NotNull private SingleImportResolver singleImportResolver; + @NotNull + private ObservableBindingTrace trace; @Inject public void setContext(@NotNull TopDownAnalysisContext context) { @@ -56,6 +58,11 @@ public class ImportsResolver { this.configuration = configuration; } + @Inject + public void setTrace(@NotNull ObservableBindingTrace trace) { + this.trace = trace; + } + public ImportsResolver() { this.singleImportResolver = new SingleImportResolver(); } @@ -71,7 +78,7 @@ public class ImportsResolver { // On first phase all classes and objects are imported, // on second phase previous imports are thrown and everything (including functions and properties at namespace level) is imported private void processImports(boolean firstPhase) { - TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.getTrace()); //not to trace errors of default imports + TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); //not to trace errors of default imports for (JetFile file : context.getNamespaceDescriptors().keySet()) { WritableScope namespaceScope = context.getNamespaceScopes().get(file); Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope, firstPhase); @@ -87,7 +94,7 @@ public class ImportsResolver { List importDirectives = file.getImportDirectives(); for (JetImportDirective importDirective : importDirectives) { - Collection descriptors = singleImportResolver.processImportReference(importDirective, namespaceScope, delayedImporter, context.getTrace(), firstPhase); + Collection descriptors = singleImportResolver.processImportReference(importDirective, namespaceScope, delayedImporter, trace, firstPhase); if (descriptors.size() == 1) { resolvedDirectives.put(importDirective, descriptors.iterator().next()); } @@ -154,10 +161,10 @@ public class ImportsResolver { isResolved = namespaceScope.getNamespace(aliasName); } if (isResolved != null && isResolved != wasResolved) { - context.getTrace().report(USELESS_HIDDEN_IMPORT.on(importedReference)); + trace.report(USELESS_HIDDEN_IMPORT.on(importedReference)); } if (!importDirective.isAllUnder() && importedReference instanceof JetSimpleNameExpression && importDirective.getAliasName() == null) { - context.getTrace().report(USELESS_SIMPLE_IMPORT.on(importedReference)); + trace.report(USELESS_SIMPLE_IMPORT.on(importedReference)); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java index 4682a5838c2..1207d451ba4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java @@ -44,7 +44,7 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.RESOLUTION_SCOPE; public class NamespaceFactoryImpl implements NamespaceFactory { private ModuleDescriptor moduleDescriptor; - private TopDownAnalysisContext context; + private BindingTrace trace; private ModuleConfiguration configuration; @Inject @@ -53,8 +53,8 @@ public class NamespaceFactoryImpl implements NamespaceFactory { } @Inject - public void setContext(TopDownAnalysisContext context) { - this.context = context; + public void setTrace(BindingTrace trace) { + this.trace = trace; } @Inject @@ -83,14 +83,14 @@ public class NamespaceFactoryImpl implements NamespaceFactory { currentOwner = namespaceDescriptor; - context.getTrace().record(REFERENCE_TARGET, nameExpression, currentOwner); - context.getTrace().record(RESOLUTION_SCOPE, nameExpression, outerScope); + trace.record(REFERENCE_TARGET, nameExpression, currentOwner); + trace.record(RESOLUTION_SCOPE, nameExpression, outerScope); outerScope = namespaceDescriptor.getMemberScope(); } String name = JetPsiUtil.safeName(namespaceHeader.getName()); - context.getTrace().record(RESOLUTION_SCOPE, namespaceHeader, outerScope); + trace.record(RESOLUTION_SCOPE, namespaceHeader, outerScope); return createNamespaceDescriptorIfNeeded(file, currentOwner, name, false); } @@ -130,19 +130,19 @@ public class NamespaceFactoryImpl implements NamespaceFactory { Collections.emptyList(), // TODO: annotations name ); - context.getTrace().record(FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName, namespaceDescriptor); - WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope"); + trace.record(FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName, namespaceDescriptor); + WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Namespace member scope"); scope.changeLockLevel(WritableScope.LockLevel.BOTH); namespaceDescriptor.initialize(scope); - configuration.extendNamespaceScope(context.getTrace(), namespaceDescriptor, scope); + configuration.extendNamespaceScope(trace, namespaceDescriptor, scope); owner.addNamespace(namespaceDescriptor); if (file != null) { - context.getTrace().record(BindingContext.NAMESPACE, file, namespaceDescriptor); + trace.record(BindingContext.NAMESPACE, file, namespaceDescriptor); } } if (file != null) { - context.getTrace().record(BindingContext.FILE_TO_NAMESPACE, file, namespaceDescriptor); + trace.record(BindingContext.FILE_TO_NAMESPACE, file, namespaceDescriptor); } return namespaceDescriptor; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java index 09f8526d118..9b7995d376d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java @@ -37,6 +37,7 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED; */ public class OverloadResolver { private TopDownAnalysisContext context; + private BindingTrace trace; @Inject @@ -44,6 +45,12 @@ public class OverloadResolver { this.context = context; } + @Inject + public void setTrace(BindingTrace trace) { + this.trace = trace; + } + + public void process() { checkOverloads(); @@ -186,16 +193,16 @@ public class OverloadResolver { OverloadUtil.OverloadCompatibilityInfo overloadable = OverloadUtil.isOverloadable(function, function2); if (!overloadable.isSuccess()) { - JetDeclaration member = (JetDeclaration) context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, function); + JetDeclaration member = (JetDeclaration) trace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, function); if (member == null) { - assert context.getTrace().get(DELEGATED, function); + assert trace.get(DELEGATED, function); return; } if (function instanceof PropertyDescriptor) { - context.getTrace().report(Errors.REDECLARATION.on(function, context.getTrace().getBindingContext())); + trace.report(Errors.REDECLARATION.on(function, trace.getBindingContext())); } else { - context.getTrace().report(Errors.CONFLICTING_OVERLOADS.on(member, function, functionContainer)); + trace.report(Errors.CONFLICTING_OVERLOADS.on(member, function, functionContainer)); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java index 32dd8aa3269..e64b9204603 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java @@ -46,6 +46,7 @@ public class OverrideResolver { private TopDownAnalysisContext context; private TopDownAnalysisParameters topDownAnalysisParameters; + private BindingTrace trace; @Inject @@ -58,6 +59,11 @@ public class OverrideResolver { this.topDownAnalysisParameters = topDownAnalysisParameters; } + @Inject + public void setTrace(BindingTrace trace) { + this.trace = trace; + } + public void process() { @@ -126,8 +132,8 @@ public class OverrideResolver { @Override public void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent) { - JetDeclaration jetProperty = (JetDeclaration) context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, fromCurrent); - context.getTrace().report(Errors.CONFLICTING_OVERLOADS.on(jetProperty, fromCurrent, fromCurrent.getContainingDeclaration().getName())); + JetDeclaration jetProperty = (JetDeclaration) trace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, fromCurrent); + trace.report(Errors.CONFLICTING_OVERLOADS.on(jetProperty, fromCurrent, fromCurrent.getContainingDeclaration().getName())); } }); } @@ -245,7 +251,7 @@ public class OverrideResolver { if (nameIdentifier == null) return; for (CallableMemberDescriptor memberDescriptor : manyImpl) { - context.getTrace().report(MANY_IMPL_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, memberDescriptor)); + trace.report(MANY_IMPL_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, memberDescriptor)); break; } @@ -255,7 +261,7 @@ public class OverrideResolver { } for (CallableMemberDescriptor memberDescriptor : abstractNoImpl) { - context.getTrace().report(ABSTRACT_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, memberDescriptor)); + trace.report(ABSTRACT_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, memberDescriptor)); break; } @@ -278,9 +284,9 @@ public class OverrideResolver { // if (functionDescriptor.getModality() == Modality.ABSTRACT && !allOverriddenFunctions.contains(functionDescriptor.getOriginal()) && !foundError && nameIdentifier != null) { // DeclarationDescriptor declarationDescriptor = functionDescriptor.getContainingDeclaration(); // if (declarationDescriptor != classDescriptor) { -//// context.getTrace().getErrorHandler().genericError(nameIdentifier.getNode(), "Class '" + klass.getName() + "' must be declared abstract or implement abstract method '" + +//// trace.getErrorHandler().genericError(nameIdentifier.getNode(), "Class '" + klass.getName() + "' must be declared abstract or implement abstract method '" + //// functionDescriptor.getName() + "' declared in " + declarationDescriptor.getName()); -// context.getTrace().report(ABSTRACT_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, functionDescriptor)); +// trace.report(ABSTRACT_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, functionDescriptor)); // foundError = true; // } // } @@ -356,9 +362,9 @@ public class OverrideResolver { } private void checkOverride(CallableMemberDescriptor declared) { - JetNamedDeclaration member = (JetNamedDeclaration) context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, declared); + JetNamedDeclaration member = (JetNamedDeclaration) trace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, declared); if (member == null) { - assert context.getTrace().get(DELEGATED, declared); + assert trace.get(DELEGATED, declared); return; } @@ -377,29 +383,29 @@ public class OverrideResolver { if (overridden != null) { if (hasOverrideModifier) { if (!overridden.getModality().isOverridable() && !finalOverriddenError) { - context.getTrace().report(OVERRIDING_FINAL_MEMBER.on(overrideNode.getPsi(), overridden, overridden.getContainingDeclaration())); + trace.report(OVERRIDING_FINAL_MEMBER.on(overrideNode.getPsi(), overridden, overridden.getContainingDeclaration())); finalOverriddenError = true; } if (!OverridingUtil.isReturnTypeOkForOverride(JetTypeChecker.INSTANCE, overridden, declared) && !typeMismatchError) { - context.getTrace().report(RETURN_TYPE_MISMATCH_ON_OVERRIDE.on(member, declared, overridden)); + trace.report(RETURN_TYPE_MISMATCH_ON_OVERRIDE.on(member, declared, overridden)); typeMismatchError = true; } if (checkPropertyKind(overridden, true) && checkPropertyKind(declared, false) && !kindMismatchError) { - context.getTrace().report(VAR_OVERRIDDEN_BY_VAL.on((JetProperty) member, (PropertyDescriptor) declared, (PropertyDescriptor) overridden)); + trace.report(VAR_OVERRIDDEN_BY_VAL.on((JetProperty) member, (PropertyDescriptor) declared, (PropertyDescriptor) overridden)); kindMismatchError = true; } } } } if (hasOverrideModifier && declared.getOverriddenDescriptors().size() == 0) { - context.getTrace().report(NOTHING_TO_OVERRIDE.on(member, declared)); + trace.report(NOTHING_TO_OVERRIDE.on(member, declared)); } PsiElement nameIdentifier = member.getNameIdentifier(); if (!hasOverrideModifier && declared.getOverriddenDescriptors().size() > 0 && nameIdentifier != null) { CallableMemberDescriptor overridden = declared.getOverriddenDescriptors().iterator().next(); - context.getTrace().report(VIRTUAL_MEMBER_HIDDEN.on(member, declared, overridden, overridden.getContainingDeclaration())); + trace.report(VIRTUAL_MEMBER_HIDDEN.on(member, declared, overridden, overridden.getContainingDeclaration())); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java index 7940da746da..8a2a4da12d6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java @@ -36,8 +36,6 @@ import java.util.Set; */ public class TopDownAnalysisContext { - private ObservableBindingTrace trace; - private final Map classes = Maps.newLinkedHashMap(); private final Map objects = Maps.newLinkedHashMap(); protected final Map namespaceScopes = Maps.newHashMap(); @@ -57,7 +55,6 @@ public class TopDownAnalysisContext { @Inject public void setTopDownAnalysisParameters(TopDownAnalysisParameters topDownAnalysisParameters) { this.topDownAnalysisParameters = topDownAnalysisParameters; - this.trace = new ObservableBindingTrace(topDownAnalysisParameters.getTrace()); } @@ -90,11 +87,6 @@ public class TopDownAnalysisContext { return result; } - @NotNull - public ObservableBindingTrace getTrace() { - return trace; - } - public Map getClasses() { return classes; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java index 3f1d5340d60..f59e7b68d3c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java @@ -30,18 +30,14 @@ public class TopDownAnalysisParameters { private final Predicate analyzeCompletely; private final boolean analyzingBootstrapLibrary; private final boolean declaredLocally; - @NotNull - private final BindingTrace trace; public TopDownAnalysisParameters( @NotNull Predicate analyzeCompletely, boolean analyzingBootstrapLibrary, - boolean declaredLocally, - @NotNull BindingTrace trace) { + boolean declaredLocally) { this.analyzeCompletely = analyzeCompletely; this.analyzingBootstrapLibrary = analyzingBootstrapLibrary; this.declaredLocally = declaredLocally; - this.trace = trace; } @NotNull @@ -56,9 +52,4 @@ public class TopDownAnalysisParameters { public boolean isDeclaredLocally() { return declaredLocally; } - - @NotNull - public BindingTrace getTrace() { - return trace; - } } 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 37af495eb5f..fb7fc0dd049 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -60,6 +60,8 @@ public class TopDownAnalyzer { @NotNull private TopDownAnalysisContext context; @NotNull + private BindingTrace trace; + @NotNull private ModuleConfiguration configuration; @NotNull private ModuleDescriptor moduleDescriptor; @@ -100,6 +102,11 @@ public class TopDownAnalyzer { this.topDownAnalysisParameters = topDownAnalysisParameters; } + @Inject + public void setTrace(@NotNull BindingTrace trace) { + this.trace = trace; + } + @Inject public void setContext(@NotNull TopDownAnalysisContext context) { this.context = context; @@ -150,9 +157,10 @@ public class TopDownAnalyzer { @NotNull ModuleConfiguration configuration, boolean declaredLocally) { - TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(analyzeCompletely, false, declaredLocally, trace); + TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(analyzeCompletely, false, declaredLocally); - InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(project, topDownAnalysisParameters, moduleDescriptor, flowDataTraceFactory, configuration); + InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( + project, topDownAnalysisParameters, new ObservableBindingTrace(trace), moduleDescriptor, flowDataTraceFactory, configuration); injector.getTopDownAnalyzer().doProcess(outerScope, owner, declarations); @@ -204,9 +212,9 @@ public class TopDownAnalyzer { @NotNull NamespaceDescriptorImpl standardLibraryNamespace, @NotNull List files) { - TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(Predicates.alwaysFalse(), true, false, trace); + TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(Predicates.alwaysFalse(), true, false); InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( - project, topDownAnalysisParameters, + project, topDownAnalysisParameters, new ObservableBindingTrace(trace), JetStandardClasses.FAKE_STANDARD_CLASSES_MODULE, null, ModuleConfiguration.EMPTY); injector.getTopDownAnalyzer().doProcessStandardLibraryNamespace(outerScope, standardLibraryNamespace, files); @@ -274,10 +282,10 @@ public class TopDownAnalyzer { final ModuleDescriptor owner = new ModuleDescriptor(""); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - filesToAnalyzeCompletely, false, false, bindingTraceContext); + filesToAnalyzeCompletely, false, false); InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( - project, topDownAnalysisParameters, owner, flowDataTraceFactory, configuration); + project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, flowDataTraceFactory, configuration); injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(files); @@ -286,7 +294,7 @@ public class TopDownAnalyzer { public void doAnalyzeFilesWithGivenTrance2(Collection files) { final WritableScope scope = new WritableScopeImpl( JetScope.EMPTY, moduleDescriptor, - new TraceBasedRedeclarationHandler(topDownAnalysisParameters.getTrace())).setDebugName("Root scope in analyzeNamespace"); + new TraceBasedRedeclarationHandler(trace)).setDebugName("Root scope in analyzeNamespace"); scope.changeLockLevel(WritableScope.LockLevel.BOTH); NamespaceDescriptorImpl rootNs = namespaceFactory.createNamespaceDescriptorPathIfNeeded(FqName.ROOT); 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 8294230c144..d76dbb44db8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -23,13 +23,11 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiNameIdentifierOwner; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.resolve.scopes.WriteThroughScope; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeConstructor; @@ -56,6 +54,8 @@ public class TypeHierarchyResolver { private DescriptorResolver descriptorResolver; @NotNull private NamespaceFactoryImpl namespaceFactory; + @NotNull + private BindingTrace trace; // state private LinkedList topologicalOrder; @@ -80,6 +80,11 @@ public class TypeHierarchyResolver { this.namespaceFactory = namespaceFactory; } + @Inject + public void setTrace(@NotNull ObservableBindingTrace trace) { + this.trace = trace; + } + public void process(@NotNull JetScope outerScope, @NotNull NamespaceLikeBuilder owner, @NotNull Collection declarations) { @@ -115,7 +120,7 @@ public class TypeHierarchyResolver { NamespaceDescriptorImpl namespaceDescriptor = namespaceFactory.createNamespaceDescriptorPathIfNeeded(file, outerScope); context.getNamespaceDescriptors().put(file, namespaceDescriptor); - WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), new TraceBasedRedeclarationHandler(context.getTrace())); + WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), new TraceBasedRedeclarationHandler(trace)); namespaceScope.changeLockLevel(WritableScope.LockLevel.BOTH); context.getNamespaceScopes().put(file, namespaceScope); @@ -124,11 +129,11 @@ public class TypeHierarchyResolver { @Override public void visitClass(JetClass klass) { - MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(context.getTrace(), owner.getOwnerForChildren(), outerScope, getClassKind(klass)); - context.getTrace().record(FQNAME_TO_CLASS_DESCRIPTOR, JetPsiUtil.getFQName(klass), mutableClassDescriptor); + MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(trace, owner.getOwnerForChildren(), outerScope, getClassKind(klass)); + trace.record(FQNAME_TO_CLASS_DESCRIPTOR, JetPsiUtil.getFQName(klass), mutableClassDescriptor); if (klass.hasModifier(JetTokens.ENUM_KEYWORD)) { - MutableClassDescriptor classObjectDescriptor = new MutableClassDescriptor(context.getTrace(), mutableClassDescriptor, outerScope, ClassKind.OBJECT); + MutableClassDescriptor classObjectDescriptor = new MutableClassDescriptor(trace, mutableClassDescriptor, outerScope, ClassKind.OBJECT); classObjectDescriptor.setName("class-object-for-" + klass.getName()); classObjectDescriptor.setModality(Modality.FINAL); classObjectDescriptor.setVisibility(DescriptorResolver.resolveVisibilityFromModifiers(klass.getModifierList())); @@ -146,7 +151,7 @@ public class TypeHierarchyResolver { @Override public void visitObjectDeclaration(JetObjectDeclaration declaration) { final MutableClassDescriptor objectDescriptor = createClassDescriptorForObject(declaration, owner, outerScope, ClassKind.OBJECT); - context.getTrace().record(FQNAME_TO_CLASS_DESCRIPTOR, JetPsiUtil.getFQName(declaration), objectDescriptor); + trace.record(FQNAME_TO_CLASS_DESCRIPTOR, JetPsiUtil.getFQName(declaration), objectDescriptor); } @Override @@ -157,7 +162,7 @@ public class TypeHierarchyResolver { createClassDescriptorForObject(enumEntry, classObjectDescriptor, outerScopeForStatic, ClassKind.ENUM_ENTRY); return; } - MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(context.getTrace(), classObjectDescriptor, outerScope, ClassKind.ENUM_ENTRY); + MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(trace, classObjectDescriptor, outerScope, ClassKind.ENUM_ENTRY); visitClassOrObject( enumEntry, (Map) context.getClasses(), @@ -167,7 +172,7 @@ public class TypeHierarchyResolver { } private MutableClassDescriptor createClassDescriptorForObject(@NotNull JetClassOrObject declaration, @NotNull NamespaceLikeBuilder owner, JetScope scope, ClassKind classKind) { - MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(context.getTrace(), owner.getOwnerForChildren(), scope, classKind) { + MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(trace, owner.getOwnerForChildren(), scope, classKind) { @Override public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptorLite classObjectDescriptor) { return ClassObjectStatus.NOT_ALLOWED; @@ -177,7 +182,7 @@ public class TypeHierarchyResolver { visitClassOrObject(declaration, map, mutableClassDescriptor); createPrimaryConstructorForObject((JetDeclaration) declaration, mutableClassDescriptor); owner.addObjectDescriptor(mutableClassDescriptor); - context.getTrace().record(BindingContext.CLASS, declaration, mutableClassDescriptor); + trace.record(BindingContext.CLASS, declaration, mutableClassDescriptor); return mutableClassDescriptor; } @@ -186,9 +191,9 @@ public class TypeHierarchyResolver { constructorDescriptor.initialize(Collections.emptyList(), Collections.emptyList(), Visibility.INTERNAL);//TODO check set mutableClassDescriptor.getVisibility() // TODO : make the constructor private? - mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor, context.getTrace()); + mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor, trace); if (object != null) { - context.getTrace().record(CONSTRUCTOR, object, constructorDescriptor); + trace.record(CONSTRUCTOR, object, constructorDescriptor); } } @@ -204,7 +209,7 @@ public class TypeHierarchyResolver { @Override public void visitTypedef(JetTypedef typedef) { - context.getTrace().report(UNSUPPORTED.on(typedef, "TypeHierarchyResolver")); + trace.report(UNSUPPORTED.on(typedef, "TypeHierarchyResolver")); } @Override @@ -214,10 +219,10 @@ public class TypeHierarchyResolver { NamespaceLikeBuilder.ClassObjectStatus status = owner.setClassObjectDescriptor(createClassDescriptorForObject(objectDeclaration, owner, outerScopeForStatic, ClassKind.OBJECT)); switch (status) { case DUPLICATE: - context.getTrace().report(MANY_CLASS_OBJECTS.on(classObject)); + trace.report(MANY_CLASS_OBJECTS.on(classObject)); break; case NOT_ALLOWED: - context.getTrace().report(CLASS_OBJECT_NOT_ALLOWED.on(classObject)); + trace.report(CLASS_OBJECT_NOT_ALLOWED.on(classObject)); break; } } @@ -238,7 +243,7 @@ public class TypeHierarchyResolver { for (Map.Entry entry : context.getClasses().entrySet()) { JetClass jetClass = entry.getKey(); MutableClassDescriptor descriptor = entry.getValue(); - descriptorResolver.resolveMutableClassDescriptor(jetClass, descriptor, context.getTrace()); + descriptorResolver.resolveMutableClassDescriptor(jetClass, descriptor, trace); descriptor.createTypeConstructor(); } for (Map.Entry entry : context.getObjects().entrySet()) { @@ -255,13 +260,13 @@ public class TypeHierarchyResolver { for (Map.Entry entry : context.getClasses().entrySet()) { JetClass jetClass = entry.getKey(); MutableClassDescriptor descriptor = entry.getValue(); - descriptorResolver.resolveGenericBounds(jetClass, descriptor.getScopeForSupertypeResolution(), descriptor.getTypeConstructor().getParameters(), context.getTrace()); - descriptorResolver.resolveSupertypes(jetClass, descriptor, context.getTrace()); + descriptorResolver.resolveGenericBounds(jetClass, descriptor.getScopeForSupertypeResolution(), descriptor.getTypeConstructor().getParameters(), trace); + descriptorResolver.resolveSupertypes(jetClass, descriptor, trace); } for (Map.Entry entry : context.getObjects().entrySet()) { JetClassOrObject jetClass = entry.getKey(); MutableClassDescriptor descriptor = entry.getValue(); - descriptorResolver.resolveSupertypes(jetClass, descriptor, context.getTrace()); + descriptorResolver.resolveSupertypes(jetClass, descriptor, trace); } } @@ -344,7 +349,7 @@ public class TypeHierarchyResolver { if (!found) continue; ClassDescriptor superclass = (i < size - 1) ? currentPath.get(i + 1) : current; - PsiElement psiElement = context.getTrace().get(DESCRIPTOR_TO_DECLARATION, classDescriptor); + PsiElement psiElement = trace.get(DESCRIPTOR_TO_DECLARATION, classDescriptor); PsiElement elementToMark = null; if (psiElement instanceof JetClassOrObject) { @@ -352,7 +357,7 @@ public class TypeHierarchyResolver { for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) { JetTypeReference typeReference = delegationSpecifier.getTypeReference(); if (typeReference == null) continue; - JetType supertype = context.getTrace().get(TYPE, typeReference); + JetType supertype = trace.get(TYPE, typeReference); if (supertype != null && supertype.getConstructor() == superclass.getTypeConstructor()) { elementToMark = typeReference; } @@ -366,7 +371,7 @@ public class TypeHierarchyResolver { } } if (elementToMark != null) { - context.getTrace().report(CYCLIC_INHERITANCE_HIERARCHY.on(elementToMark)); + trace.report(CYCLIC_INHERITANCE_HIERARCHY.on(elementToMark)); } } } @@ -404,13 +409,13 @@ public class TypeHierarchyResolver { if (conflictingTypes.size() > 1) { DeclarationDescriptor containingDeclaration = typeParameterDescriptor.getContainingDeclaration(); assert containingDeclaration instanceof ClassDescriptor : containingDeclaration; - PsiElement psiElement = context.getTrace().get(DESCRIPTOR_TO_DECLARATION, mutableClassDescriptor); + PsiElement psiElement = trace.get(DESCRIPTOR_TO_DECLARATION, mutableClassDescriptor); assert psiElement instanceof JetClassOrObject : psiElement; JetClassOrObject declaration = (JetClassOrObject) psiElement; JetDelegationSpecifierList delegationSpecifierList = declaration.getDelegationSpecifierList(); assert delegationSpecifierList != null; -// context.getTrace().getErrorHandler().genericError(delegationSpecifierList.getNode(), "Type parameter " + typeParameterDescriptor.getName() + " of " + containingDeclaration.getName() + " has inconsistent values: " + conflictingTypes); - context.getTrace().report(INCONSISTENT_TYPE_PARAMETER_VALUES.on(delegationSpecifierList, typeParameterDescriptor, (ClassDescriptor) containingDeclaration, conflictingTypes)); +// trace.getErrorHandler().genericError(delegationSpecifierList.getNode(), "Type parameter " + typeParameterDescriptor.getName() + " of " + containingDeclaration.getName() + " has inconsistent values: " + conflictingTypes); + trace.report(INCONSISTENT_TYPE_PARAMETER_VALUES.on(delegationSpecifierList, typeParameterDescriptor, (ClassDescriptor) containingDeclaration, conflictingTypes)); } } } @@ -454,9 +459,9 @@ public class TypeHierarchyResolver { for (JetDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) { JetTypeReference typeReference = delegationSpecifier.getTypeReference(); if (typeReference != null) { - JetType type = context.getTrace().getBindingContext().get(TYPE, typeReference); + JetType type = trace.getBindingContext().get(TYPE, typeReference); if (type != null) { - descriptorResolver.checkBounds(typeReference, type, context.getTrace()); + descriptorResolver.checkBounds(typeReference, type, trace); } } } @@ -464,9 +469,9 @@ public class TypeHierarchyResolver { for (JetTypeParameter jetTypeParameter : jetClass.getTypeParameters()) { JetTypeReference extendsBound = jetTypeParameter.getExtendsBound(); if (extendsBound != null) { - JetType type = context.getTrace().getBindingContext().get(TYPE, extendsBound); + JetType type = trace.getBindingContext().get(TYPE, extendsBound); if (type != null) { - descriptorResolver.checkBounds(extendsBound, type, context.getTrace()); + descriptorResolver.checkBounds(extendsBound, type, trace); } } } @@ -474,9 +479,9 @@ public class TypeHierarchyResolver { for (JetTypeConstraint constraint : jetClass.getTypeConstaints()) { JetTypeReference extendsBound = constraint.getBoundTypeReference(); if (extendsBound != null) { - JetType type = context.getTrace().getBindingContext().get(TYPE, extendsBound); + JetType type = trace.getBindingContext().get(TYPE, extendsBound); if (type != null) { - descriptorResolver.checkBounds(extendsBound, type, context.getTrace()); + descriptorResolver.checkBounds(extendsBound, type, trace); } } } diff --git a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java index 7a46ebaef10..6019f461d4e 100644 --- a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java +++ b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java @@ -56,7 +56,6 @@ public class AllInjectorsGenerator { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false); generateInjectorForTopDownAnalyzerCommon(generator); generator.addPublicField(JavaBridgeConfiguration.class); - generator.addPublicParameter(BindingTrace.class); generator.generate("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJvm"); } @@ -72,6 +71,7 @@ public class AllInjectorsGenerator { // Parameters generator.addPublicParameter(Project.class); generator.addPublicParameter(TopDownAnalysisParameters.class); + generator.addPublicParameter(ObservableBindingTrace.class); generator.addParameter(ModuleDescriptor.class); generator.addParameter(JetControlFlowDataTraceFactory.class, false); }