Do not inject TopDownAnalysisContext into DeclarationResolver

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -267,7 +267,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         scriptBodyResolver.setTrace(bindingTrace);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setContext(topDownAnalysisContext);
         declarationResolver.setDescriptorResolver(descriptorResolver);
         declarationResolver.setImportsResolver(importsResolver);
         declarationResolver.setScriptHeaderResolver(scriptHeaderResolver);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java

@@ -222,7 +222,6 @@ public class InjectorForTopDownAnalyzerBasic {
         scriptBodyResolver.setTrace(bindingTrace);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setContext(topDownAnalysisContext);
         declarationResolver.setDescriptorResolver(descriptorResolver);
         declarationResolver.setImportsResolver(importsResolver);
         declarationResolver.setScriptHeaderResolver(scriptHeaderResolver);

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

@@ -47,8 +47,6 @@ public class DeclarationResolver {
     @NotNull
     private AnnotationResolver annotationResolver;
     @NotNull
-    private TopDownAnalysisContext context;
-    @NotNull
     private ImportsResolver importsResolver;
     @NotNull
     private DescriptorResolver descriptorResolver;
@@ -63,11 +61,6 @@ public class DeclarationResolver {
         this.annotationResolver = annotationResolver;
     }
 
-    @Inject
-    public void setContext(@NotNull TopDownAnalysisContext context) {
-        this.context = context;
-    }
-
     @Inject
     public void setImportsResolver(@NotNull ImportsResolver importsResolver) {
         this.importsResolver = importsResolver;
@@ -90,20 +83,20 @@ public class DeclarationResolver {
 
 
 
-    public void process(@NotNull JetScope rootScope) {
+    public void process(@NotNull TopDownAnalysisContext c) {
-        checkModifiersAndAnnotationsInPackageDirectives();
+        checkModifiersAndAnnotationsInPackageDirectives(c);
-        resolveAnnotationConstructors();
+        resolveAnnotationConstructors(c);
-        resolveConstructorHeaders();
+        resolveConstructorHeaders(c);
-        resolveAnnotationStubsOnClassesAndConstructors();
+        resolveAnnotationStubsOnClassesAndConstructors(c);
-        resolveFunctionAndPropertyHeaders();
+        resolveFunctionAndPropertyHeaders(c);
-        createFunctionsForDataClasses();
+        createFunctionsForDataClasses(c);
         importsResolver.processMembersImports();
-        checkRedeclarationsInPackages();
+        checkRedeclarationsInPackages(c);
-        checkRedeclarationsInInnerClassNames();
+        checkRedeclarationsInInnerClassNames(c);
     }
 
-    private void checkModifiersAndAnnotationsInPackageDirectives() {
+    private void checkModifiersAndAnnotationsInPackageDirectives(@NotNull TopDownAnalysisContext c) {
-        for (JetFile file : context.getPackageFragments().keySet()) {
+        for (JetFile file : c.getPackageFragments().keySet()) {
             JetPackageDirective packageDirective = file.getPackageDirective();
             if (packageDirective == null) continue;
 
@@ -127,30 +120,30 @@ public class DeclarationResolver {
         }
     }
 
-    private void resolveAnnotationConstructors() {
+    private void resolveAnnotationConstructors(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getClasses().entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
             MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
 
             if (classOrObject instanceof JetClass && DescriptorUtils.isAnnotationClass(classDescriptor)) {
-                processPrimaryConstructor(classDescriptor, (JetClass) classOrObject);
+                processPrimaryConstructor(c, classDescriptor, (JetClass) classOrObject);
             }
         }
     }
 
-    private void resolveConstructorHeaders() {
+    private void resolveConstructorHeaders(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getClasses().entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
             MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
 
             if (classOrObject instanceof JetClass && !DescriptorUtils.isAnnotationClass(classDescriptor)) {
-                processPrimaryConstructor(classDescriptor, (JetClass) classOrObject);
+                processPrimaryConstructor(c, classDescriptor, (JetClass) classOrObject);
             }
         }
     }
 
-    private void resolveAnnotationStubsOnClassesAndConstructors() {
+    private void resolveAnnotationStubsOnClassesAndConstructors(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getClasses().entrySet()) {
             JetModifierList modifierList = entry.getKey().getModifierList();
             if (modifierList != null) {
                 MutableClassDescriptor descriptor = (MutableClassDescriptor) entry.getValue();
@@ -160,15 +153,15 @@ public class DeclarationResolver {
         }
     }
 
-    private void resolveFunctionAndPropertyHeaders() {
+    private void resolveFunctionAndPropertyHeaders(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetFile, WritableScope> entry : context.getFileScopes().entrySet()) {
+        for (Map.Entry<JetFile, WritableScope> entry : c.getFileScopes().entrySet()) {
             JetFile file = entry.getKey();
             WritableScope fileScope = entry.getValue();
-            PackageLikeBuilder packageBuilder = context.getPackageFragments().get(file).getBuilder();
+            PackageLikeBuilder packageBuilder = c.getPackageFragments().get(file).getBuilder();
 
-            resolveFunctionAndPropertyHeaders(file.getDeclarations(), fileScope, fileScope, fileScope, packageBuilder);
+            resolveFunctionAndPropertyHeaders(c, file.getDeclarations(), fileScope, fileScope, fileScope, packageBuilder);
         }
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getClasses().entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
             MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
 
@@ -178,6 +171,7 @@ public class DeclarationResolver {
             }
 
             resolveFunctionAndPropertyHeaders(
+                    c,
                     classOrObject.getDeclarations(), classDescriptor.getScopeForMemberDeclarationResolution(),
                     classDescriptor.getScopeForInitializerResolution(), classDescriptor.getScopeForMemberDeclarationResolution(),
                     classDescriptor.getBuilder());
@@ -189,6 +183,7 @@ public class DeclarationResolver {
     }
 
     private void resolveFunctionAndPropertyHeaders(
+            @NotNull final TopDownAnalysisContext c,
             @NotNull List<JetDeclaration> declarations,
             @NotNull final JetScope scopeForFunctions,
             @NotNull final JetScope scopeForPropertyInitializers,
@@ -204,11 +199,11 @@ public class DeclarationResolver {
                             scopeForFunctions,
                             function,
                             trace,
-                            context.getOuterDataFlowInfo()
+                            c.getOuterDataFlowInfo()
                     );
                     packageLike.addFunctionDescriptor(functionDescriptor);
-                    context.getFunctions().put(function, functionDescriptor);
+                    c.getFunctions().put(function, functionDescriptor);
-                    context.registerDeclaringScope(function, scopeForFunctions);
+                    c.registerDeclaringScope(function, scopeForFunctions);
                 }
 
                 @Override
@@ -218,25 +213,25 @@ public class DeclarationResolver {
                             scopeForPropertyInitializers,
                             property,
                             trace,
-                            context.getOuterDataFlowInfo());
+                            c.getOuterDataFlowInfo());
                     packageLike.addPropertyDescriptor(propertyDescriptor);
-                    context.getProperties().put(property, propertyDescriptor);
+                    c.getProperties().put(property, propertyDescriptor);
-                    context.registerDeclaringScope(property, scopeForPropertyInitializers);
+                    c.registerDeclaringScope(property, scopeForPropertyInitializers);
                     JetPropertyAccessor getter = property.getGetter();
                     if (getter != null) {
-                        context.registerDeclaringScope(getter, scopeForPropertyAccessors);
+                        c.registerDeclaringScope(getter, scopeForPropertyAccessors);
                     }
                     JetPropertyAccessor setter = property.getSetter();
                     if (setter != null) {
-                        context.registerDeclaringScope(setter, scopeForPropertyAccessors);
+                        c.registerDeclaringScope(setter, scopeForPropertyAccessors);
                     }
                 }
             });
         }
     }
 
-    private void createFunctionsForDataClasses() {
+    private void createFunctionsForDataClasses(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getClasses().entrySet()) {
             JetClassOrObject klass = entry.getKey();
             MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
 
@@ -272,7 +267,11 @@ public class DeclarationResolver {
         classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
     }
 
-    private void processPrimaryConstructor(MutableClassDescriptor classDescriptor, JetClass klass) {
+    private void processPrimaryConstructor(
+            @NotNull TopDownAnalysisContext c,
+            @NotNull MutableClassDescriptor classDescriptor,
+            @NotNull JetClass klass
+    ) {
         if (classDescriptor.getKind() == ClassKind.TRAIT) {
             JetParameterList primaryConstructorParameterList = klass.getPrimaryConstructorParameterList();
             if (primaryConstructorParameterList != null) {
@@ -300,7 +299,7 @@ public class DeclarationResolver {
                             parameter, trace
                     );
                     classDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
-                    context.getPrimaryConstructorParameterProperties().put(parameter, propertyDescriptor);
+                    c.getPrimaryConstructorParameterProperties().put(parameter, propertyDescriptor);
                 }
                 else {
                     if (isAnnotationClass) {
@@ -317,8 +316,8 @@ public class DeclarationResolver {
         }
     }
 
-    private void checkRedeclarationsInPackages() {
+    private void checkRedeclarationsInPackages(@NotNull TopDownAnalysisContext c) {
-        for (MutablePackageFragmentDescriptor packageFragment : Sets.newHashSet(context.getPackageFragments().values())) {
+        for (MutablePackageFragmentDescriptor packageFragment : Sets.newHashSet(c.getPackageFragments().values())) {
             PackageViewDescriptor packageView = packageFragment.getContainingDeclaration().getPackage(packageFragment.getFqName());
             JetScope packageViewScope = packageView.getMemberScope();
             Multimap<Name, DeclarationDescriptor> simpleNameDescriptors = packageFragment.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName();
@@ -374,8 +373,8 @@ public class DeclarationResolver {
         return declarations;
     }
 
-    private void checkRedeclarationsInInnerClassNames() {
+    private void checkRedeclarationsInInnerClassNames(@NotNull TopDownAnalysisContext c) {
-        for (ClassDescriptorWithResolutionScopes classDescriptor : context.getClasses().values()) {
+        for (ClassDescriptorWithResolutionScopes classDescriptor : c.getClasses().values()) {
             MutableClassDescriptor mutableClassDescriptor = (MutableClassDescriptor) classDescriptor;
             if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) {
                 // Class objects should be considered during analysing redeclarations in classes

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

@@ -118,7 +118,7 @@ public class TopDownAnalyzer {
         c.debug("Enter");
 
         typeHierarchyResolver.process(outerScope, owner, declarations);
-        declarationResolver.process(outerScope);
+        declarationResolver.process(c);
         overrideResolver.process();
 
         lockScopes(c);

js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java

@@ -222,7 +222,6 @@ public class InjectorForTopDownAnalyzerForJs {
         scriptBodyResolver.setTrace(bindingTrace);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setContext(topDownAnalysisContext);
         declarationResolver.setDescriptorResolver(descriptorResolver);
         declarationResolver.setImportsResolver(importsResolver);
         declarationResolver.setScriptHeaderResolver(scriptHeaderResolver);