move BindingTrace to Injector from TopDownAnalysisContext

It is necessary to make NamespaceFactoryImpl independent from TopDownAnalysisContext

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,
+        JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory
-        @NotNull BindingTrace bindingTrace
     ) {
         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;
-    }
-
 }

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("<module>");
 
         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);

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

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<JetTypeReference, JetType> 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<FunctionDescriptor> 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<JetDelegationSpecifier> 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());
+                declaringScope, propertyDescriptor, propertyDescriptor.getTypeParameters(), propertyDescriptor.getReceiverParameter(), trace);
-        WritableScope accessorScope = new WritableScopeImpl(propertyDeclarationInnerScope, declaringScope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Accessor scope");
+        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<JetReferenceExpression, DeclarationDescriptor>() {
+        return new ObservableBindingTrace(trace).addHandler(BindingContext.REFERENCE_TARGET, new ObservableBindingTrace.RecordHandler<JetReferenceExpression, DeclarationDescriptor>() {
             @Override
             public void handleRecord(WritableSlice<JetReferenceExpression, DeclarationDescriptor> 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<Box<DeferredType>> deferredTypes = context.getTrace().getKeys(DEFERRED_TYPE);
+        Collection<Box<DeferredType>> 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<DeferredType> queue = new Queue<DeferredType>(deferredTypes.size() + 1);
-            context.getTrace().addHandler(DEFERRED_TYPE, new ObservableBindingTrace.RecordHandler<Box<DeferredType>, Boolean>() {
+            trace.addHandler(DEFERRED_TYPE, new ObservableBindingTrace.RecordHandler<Box<DeferredType>, Boolean>() {
                 @Override
                 public void handleRecord(WritableSlice<Box<DeferredType>, Boolean> deferredTypeKeyDeferredTypeWritableSlice, Box<DeferredType> key, Boolean value) {
                     queue.addLast(key.getData());

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

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());
+                constructor, trace);
-        classDescriptor.addConstructor(constructorDescriptor, context.getTrace());
+        classDescriptor.addConstructor(constructorDescriptor, trace);
         context.getConstructors().put(constructor, constructorDescriptor);
         context.getDeclaringScopes().put(constructor, classDescriptor.getScopeForMemberLookup());
     }

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<JetClass, MutableClassDescriptor> 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<JetKeywordToken, ASTNode> 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));
                     }
                 }
             }

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

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<JetImportDirective> importDirectives = file.getImportDirectives();
             for (JetImportDirective importDirective : importDirectives) {
-                Collection<? extends DeclarationDescriptor> descriptors = singleImportResolver.processImportReference(importDirective, namespaceScope, delayedImporter, context.getTrace(), firstPhase);
+                Collection<? extends DeclarationDescriptor> 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));
         }
     }
 

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) {
+    public void setTrace(BindingTrace trace) {
-        this.context = context;
+        this.trace = trace;
     }
 
     @Inject
@@ -83,14 +83,14 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
 
             currentOwner = namespaceDescriptor;
 
-            context.getTrace().record(REFERENCE_TARGET, nameExpression, currentOwner);
+            trace.record(REFERENCE_TARGET, nameExpression, currentOwner);
-            context.getTrace().record(RESOLUTION_SCOPE, nameExpression, outerScope);
+            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.<AnnotationDescriptor>emptyList(), // TODO: annotations
                     name
             );
-            context.getTrace().record(FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName, namespaceDescriptor);
+            trace.record(FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName, namespaceDescriptor);
-            WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope");
+            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;

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

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);
+                            JetDeclaration jetProperty = (JetDeclaration) trace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, fromCurrent);
-                            context.getTrace().report(Errors.CONFLICTING_OVERLOADS.on(jetProperty, fromCurrent, fromCurrent.getContainingDeclaration().getName()));
+                            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()));
         }
     }
 

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<JetClass, MutableClassDescriptor> classes = Maps.newLinkedHashMap();
     private final Map<JetObjectDeclaration, MutableClassDescriptor> objects = Maps.newLinkedHashMap();
     protected final Map<JetFile, WritableScope> 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<JetClass, MutableClassDescriptor> getClasses() {
         return classes;
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java

@@ -30,18 +30,14 @@ public class TopDownAnalysisParameters {
     private final Predicate<PsiFile> analyzeCompletely;
     private final boolean analyzingBootstrapLibrary;
     private final boolean declaredLocally;
-    @NotNull
-    private final BindingTrace trace;
 
     public TopDownAnalysisParameters(
             @NotNull Predicate<PsiFile> analyzeCompletely,
             boolean analyzingBootstrapLibrary,
-            boolean declaredLocally,
+            boolean declaredLocally) {
-            @NotNull BindingTrace trace) {
         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;
-    }
 }

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<JetFile> files) {
 
-        TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(Predicates.<PsiFile>alwaysFalse(), true, false, trace);
+        TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(Predicates.<PsiFile>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("<module>");
 
         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<JetFile> 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);

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<MutableClassDescriptor> 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<? extends PsiElement> 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));
+                    MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(trace, owner.getOwnerForChildren(), outerScope, getClassKind(klass));
-                    context.getTrace().record(FQNAME_TO_CLASS_DESCRIPTOR, JetPsiUtil.getFQName(klass), mutableClassDescriptor);
+                    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.<TypeParameterDescriptor>emptyList(), Collections.<ValueParameterDescriptor>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<JetClass, MutableClassDescriptor> 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<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
@@ -255,13 +260,13 @@ public class TypeHierarchyResolver {
         for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
             JetClass jetClass = entry.getKey();
             MutableClassDescriptor descriptor = entry.getValue();
-            descriptorResolver.resolveGenericBounds(jetClass, descriptor.getScopeForSupertypeResolution(), descriptor.getTypeConstructor().getParameters(), context.getTrace());
+            descriptorResolver.resolveGenericBounds(jetClass, descriptor.getScopeForSupertypeResolution(), descriptor.getTypeConstructor().getParameters(), trace);
-            descriptorResolver.resolveSupertypes(jetClass, descriptor, context.getTrace());
+            descriptorResolver.resolveSupertypes(jetClass, descriptor, trace);
         }
         for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> 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);
+//                        trace.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.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);
                     }
                 }
             }

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