do not store root scope in context

because context can be used more then once when analyzing REPL

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

@@ -80,11 +80,11 @@ public class DeclarationResolver {
 
 
 
-    public void process() {
+    public void process(@NotNull JetScope rootScope) {
         resolveConstructorHeaders();
         resolveAnnotationStubsOnClassesAndConstructors();
         resolveFunctionAndPropertyHeaders();
-        importsResolver.processMembersImports();
+        importsResolver.processMembersImports(rootScope);
         checkRedeclarationsInNamespaces();
     }
 

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

@@ -68,28 +68,29 @@ public class ImportsResolver {
         this.qualifiedExpressionResolver = qualifiedExpressionResolver;
     }
 
-    public void processTypeImports() {
-        processImports(true);
+    public void processTypeImports(@NotNull JetScope rootScope) {
+        processImports(true, rootScope);
     }
 
-    public void processMembersImports() {
-        processImports(false);
+    public void processMembersImports(@NotNull JetScope rootScope) {
+        processImports(false, rootScope);
     }
 
-    private void processImports(boolean onlyClasses) {
+    private void processImports(boolean onlyClasses, @NotNull JetScope rootScope) {
         for (JetFile file : context.getNamespaceDescriptors().keySet()) {
             WritableScope namespaceScope = context.getNamespaceScopes().get(file);
-            processImportsInFile(onlyClasses, namespaceScope, file.getImportDirectives());
+            processImportsInFile(onlyClasses, namespaceScope, file.getImportDirectives(), rootScope);
         }
         for (JetScript script : context.getScripts().keySet()) {
             WritableScope scriptScope = context.getScriptScopes().get(script);
-            processImportsInFile(onlyClasses, scriptScope, script.getImportDirectives());
+            processImportsInFile(onlyClasses, scriptScope, script.getImportDirectives(), rootScope);
         }
     }
 
-    private void processImportsInFile(boolean onlyClasses, WritableScope namespaceScope, List<JetImportDirective> importDirectives) {
+    private void processImportsInFile(
+            boolean onlyClasses, WritableScope namespaceScope,
+            List<JetImportDirective> importDirectives, @NotNull JetScope rootScope) {
 
-        JetScope rootScope = context.getRootScope();
         Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope);
         if (!onlyClasses) {
             namespaceScope.clearImports();

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

@@ -36,7 +36,6 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
 
     private final Map<JetClass, MutableClassDescriptor> classes = Maps.newLinkedHashMap();
     private final Map<JetObjectDeclaration, MutableClassDescriptor> objects = Maps.newLinkedHashMap();
-    private JetScope rootScope;
     protected final Map<JetFile, NamespaceDescriptorImpl> namespaceDescriptors = Maps.newHashMap();
 
     private final Map<JetDeclaration, JetScope> declaringScopes = Maps.newHashMap();
@@ -114,16 +113,6 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
         return namespaceScopes;
     }
 
-    public void setRootScope(@NotNull JetScope scope) {
-        assert rootScope == null;
-        rootScope = scope;
-    }
-
-    @NotNull
-    public JetScope getRootScope() {
-        return rootScope;
-    }
-
     public Map<JetFile, NamespaceDescriptorImpl> getNamespaceDescriptors() {
         return namespaceDescriptors;
     }

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

@@ -156,7 +156,7 @@ public class TopDownAnalyzer {
         context.debug("Enter");
 
         typeHierarchyResolver.process(outerScope, owner, declarations);
-        declarationResolver.process();
+        declarationResolver.process(outerScope);
         delegationResolver.process();
         overrideResolver.process();
 

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

@@ -96,7 +96,6 @@ public class TypeHierarchyResolver {
 
     public void process(@NotNull JetScope outerScope, @NotNull NamespaceLikeBuilder owner,
                         @NotNull Collection<? extends PsiElement> declarations) {
-        context.setRootScope(outerScope);
 
         {
             // TODO: Very temp code - main goal is to remove recursion from collectNamespacesAndClassifiers
@@ -131,7 +130,7 @@ public class TypeHierarchyResolver {
             }
         }
 
-        importsResolver.processTypeImports();
+        importsResolver.processTypeImports(outerScope);
 
         createTypeConstructors(); // create type constructors for classes and generic parameters, supertypes are not filled in
         resolveTypesInClassHeaders(); // Generic bounds and types in supertype lists (no expressions or constructor resolution)