Refactor: Remove ScopeProvider, introduce FileScopeProviderImpl

Rename NoFileScopeProvider -> FileScopeProvider.ThrowException, ScopeProvider.AdditionalScopeProvider -> FileScopeProvider.AdditionalScopes

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java

@@ -56,8 +56,8 @@ import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
+import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.kotlin.resolve.lazy.declarations.*;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -111,7 +111,7 @@ public class ReplInterpreter {
 
         scriptDeclarationFactory = new ScriptMutableDeclarationProviderFactory();
 
-        ScopeProvider.AdditionalFileScopeProvider scopeProvider = new ScopeProvider.AdditionalFileScopeProvider() {
+        FileScopeProvider.AdditionalScopes scopeProvider = new FileScopeProvider.AdditionalScopes() {
             @NotNull
             @Override
             public List<JetScope> scopes(@NotNull JetFile file) {
@@ -128,7 +128,7 @@ public class ReplInterpreter {
         );
 
         this.topDownAnalysisContext = new TopDownAnalysisContext(TopDownAnalysisMode.LocalDeclarations, DataFlowInfo.EMPTY,
-                                                                 container.getResolveSession().getScopeProvider());
+                                                                 container.getResolveSession().getDeclarationScopeProvider());
         this.topDownAnalyzer = container.getLazyTopDownAnalyzerForTopLevel();
         this.resolveSession = container.getResolveSession();
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt

@@ -29,13 +29,14 @@ import org.jetbrains.kotlin.resolve.BodyResolveCache
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
 import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
+import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider
+import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 
 public fun createContainerForReplWithJava(
         moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
-        moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: ScopeProvider.AdditionalFileScopeProvider
+        moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: FileScopeProvider.AdditionalScopes
 ): ContainerForReplWithJava = createContainer("ReplWithJava") {
     configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
@@ -44,7 +45,7 @@ public fun createContainerForReplWithJava(
     useInstance(declarationProviderFactory)
     useInstance(BodyResolveCache.ThrowException)
 
-    useImpl<ScopeProvider>()
+    useImpl<FileScopeProviderImpl>()
     useImpl<SingleModuleClassResolver>()
 }.let {
     it.get<JavaClassFinderImpl>().initialize()

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -39,8 +39,8 @@ import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
 import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct
+import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 
 public fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentScope: GlobalSearchScope, project: Project) {
@@ -78,7 +78,7 @@ public fun createContainerForLazyResolveWithJava(
 
     useInstance(declarationProviderFactory)
     useInstance(BodyResolveCache.ThrowException)
-    useImpl<ScopeProvider>()
+    useImpl<FileScopeProviderImpl>()
     useImpl<LazyResolveToken>()
 }.let {
     it.javaAnalysisInit()
@@ -98,7 +98,7 @@ public fun createContainerForTopDownAnalyzerForJvm(
     useInstance(BodyResolveCache.ThrowException)
 
     useImpl<SingleModuleClassResolver>()
-    useImpl<ScopeProvider>()
+    useImpl<FileScopeProviderImpl>()
 }.let {
     it.javaAnalysisInit()
 

compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt

@@ -23,8 +23,8 @@ import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.CallResolver
+import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
-import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider
 import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
@@ -73,7 +73,7 @@ public fun createContainerForLazyBodyResolve(
     configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
 
     useInstance(kotlinCodeAnalyzer)
-    useInstance(kotlinCodeAnalyzer.getScopeProvider())
+    useInstance(kotlinCodeAnalyzer.getFileScopeProvider())
     useInstance(dynamicTypesSettings)
     useInstance(bodyResolveCache)
     useImpl<LazyTopDownAnalyzerForTopLevel>()
@@ -94,8 +94,8 @@ public fun createContainerForLazyLocalClassifierAnalyzer(
     useImpl<LazyTopDownAnalyzer>()
 
     useInstance(NoTopLevelDescriptorProvider)
-    useInstance(NoFileScopeProvider)
     useInstance(BodyResolveCache.ThrowException)
+    useInstance(FileScopeProvider.ThrowException)
 
     useImpl<DeclarationScopeProviderForLocalClassifierAnalyzer>()
     useImpl<LocalLazyDeclarationResolver>()

compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java

@@ -92,7 +92,7 @@ public class LazyTopDownAnalyzerForTopLevel {
     }
 
     private static void resolveAndCheckImports(@NotNull JetFile file, @NotNull KotlinCodeAnalyzer resolveSession) {
-        LazyFileScope fileScope = resolveSession.getScopeProvider().getFileScope(file);
+        LazyFileScope fileScope = resolveSession.getFileScopeProvider().getFileScope(file);
         fileScope.forceResolveAllImports();
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProviderImpl.java

@@ -24,21 +24,18 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 
-import javax.inject.Inject;
-
 public class DeclarationScopeProviderImpl implements DeclarationScopeProvider {
 
     private final LazyDeclarationResolver lazyDeclarationResolver;
 
-    private FileScopeProvider fileScopeProvider;
+    private final FileScopeProvider fileScopeProvider;
 
-    @Inject
-    public void setFileScopeProvider(@NotNull FileScopeProvider fileScopeProvider) {
-        this.fileScopeProvider = fileScopeProvider;
-    }
-
-    public DeclarationScopeProviderImpl(@NotNull LazyDeclarationResolver lazyDeclarationResolver) {
+    public DeclarationScopeProviderImpl(
+            @NotNull LazyDeclarationResolver lazyDeclarationResolver,
+            @NotNull FileScopeProvider fileScopeProvider
+    ) {
         this.lazyDeclarationResolver = lazyDeclarationResolver;
+        this.fileScopeProvider = fileScopeProvider;
     }
 
     @Override

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt

@@ -19,12 +19,19 @@ package org.jetbrains.kotlin.resolve.lazy
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 
-public trait FileScopeProvider {
-    fun getFileScope(jetFile: JetFile): JetScope
+public interface FileScopeProvider {
+    fun getFileScope(file: JetFile): LazyFileScope
+
+    public object ThrowException : FileScopeProvider {
+        override fun getFileScope(file: JetFile): LazyFileScope {
+            throw UnsupportedOperationException("Should not be called")
+        }
+    }
+
+    public open class AdditionalScopes {
+        public open fun scopes(file: JetFile): List<JetScope> {
+            return emptyList()
+        }
+    }
 }
 
-public object NoFileScopeProvider : FileScopeProvider {
-    override fun getFileScope(jetFile: JetFile): JetScope {
-        throw UnsupportedOperationException("Should not be called")
-    }
-}

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.resolve.lazy
+
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
+import org.jetbrains.kotlin.storage.get
+
+public class FileScopeProviderImpl(
+        private val resolveSession: ResolveSession,
+        private val additionalScopes: FileScopeProvider.AdditionalScopes
+) : FileScopeProvider {
+
+    private val defaultImports by resolveSession.getStorageManager().createLazyValue {
+        val defaultImports = resolveSession.getModuleDescriptor().defaultImports
+        resolveSession.getJetImportsFactory().createImportDirectives(defaultImports)
+    }
+
+    private val fileScopes = resolveSession.getStorageManager().createMemoizedFunction { file: JetFile -> createFileScope(file) }
+
+    override fun getFileScope(file: JetFile) = fileScopes(file)
+
+    private fun createFileScope(file: JetFile): LazyFileScope {
+        val tempTrace = TemporaryBindingTrace.create(resolveSession.getTrace(), "Transient trace for default imports lazy resolve")
+        return LazyFileScope.create(
+                resolveSession, file, defaultImports, additionalScopes.scopes(file),
+                resolveSession.getTrace(), tempTrace, "LazyFileScope for file " + file.getName()
+        )
+    }
+}

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/KotlinCodeAnalyzer.java

@@ -17,18 +17,14 @@
 package org.jetbrains.kotlin.resolve.lazy;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
-import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.JetClassOrObject;
 import org.jetbrains.kotlin.psi.JetDeclaration;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
-import java.util.Collection;
-
 public interface KotlinCodeAnalyzer extends TopLevelDescriptorProvider {
 
     @NotNull
@@ -44,7 +40,10 @@ public interface KotlinCodeAnalyzer extends TopLevelDescriptorProvider {
     DeclarationDescriptor resolveToDescriptor(@NotNull JetDeclaration declaration);
 
     @NotNull
-    ScopeProvider getScopeProvider();
+    DeclarationScopeProvider getDeclarationScopeProvider();
+
+    @NotNull
+    FileScopeProvider getFileScopeProvider();
 
     /**
      * Forces all descriptors to be resolved.

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt

@@ -16,13 +16,13 @@
 
 package org.jetbrains.kotlin.resolve.lazy
 
-import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.storage.StorageManager
 
 public trait LazyClassContext {
-    val scopeProvider: DeclarationScopeProvider
+    val declarationScopeProvider: DeclarationScopeProvider
 
     val storageManager: StorageManager
     val trace: BindingTrace

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt

@@ -29,9 +29,8 @@ import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.util.collectionUtils.concat
-import java.util.HashSet
+import org.jetbrains.kotlin.utils.Printer
 import java.util.LinkedHashSet
 import kotlin.properties.Delegates
 
@@ -127,7 +126,7 @@ class LazyImportResolver(
 
         val status = importedScopesProvider(importDirective).importResolveStatus
         if (status != null && !status.descriptors.isEmpty()) {
-            val fileScope = resolveSession.getScopeProvider().getFileScope(importDirective.getContainingJetFile())
+            val fileScope = resolveSession.getFileScopeProvider().getFileScope(importDirective.getContainingJetFile())
             reportConflictingImport(importDirective, fileScope, status.descriptors, traceForImportResolve)
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java

@@ -64,8 +64,6 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
     private final MemoizedFunctionToNotNull<JetFile, LazyAnnotations> fileAnnotations;
     private final MemoizedFunctionToNotNull<JetFile, LazyAnnotations> danglingAnnotations;
 
-    private ScopeProvider scopeProvider;
-
     private JetImportsFactory jetImportFactory;
     private AnnotationResolver annotationResolve;
     private DescriptorResolver descriptorResolver;
@@ -74,6 +72,8 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
     private QualifiedExpressionResolver qualifiedExpressionResolver;
     private ScriptBodyResolver scriptBodyResolver;
     private LazyDeclarationResolver lazyDeclarationResolver;
+    private FileScopeProvider fileScopeProvider;
+    private DeclarationScopeProvider declarationScopeProvider;
 
     @Inject
     public void setJetImportFactory(JetImportsFactory jetImportFactory) {
@@ -105,11 +105,6 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
         this.qualifiedExpressionResolver = qualifiedExpressionResolver;
     }
 
-    @Inject
-    public void setScopeProvider(ScopeProvider scopeProvider) {
-        this.scopeProvider = scopeProvider;
-    }
-
     @Inject
     public void setScriptBodyResolver(ScriptBodyResolver scriptBodyResolver) {
         this.scriptBodyResolver = scriptBodyResolver;
@@ -120,6 +115,16 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
         this.lazyDeclarationResolver = lazyDeclarationResolver;
     }
 
+    @Inject
+    public void setFileScopeProvider(@NotNull FileScopeProviderImpl fileScopeProvider) {
+        this.fileScopeProvider = fileScopeProvider;
+    }
+
+    @Inject
+    public void setDeclarationScopeProvider(@NotNull DeclarationScopeProviderImpl declarationScopeProvider) {
+        this.declarationScopeProvider = declarationScopeProvider;
+    }
+
     // Only calls from injectors expected
     @Deprecated
     public ResolveSession(
@@ -197,7 +202,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
     }
 
     private LazyAnnotations createAnnotations(JetFile file, List<JetAnnotationEntry> annotationEntries) {
-        JetScope scope = getScopeProvider().getFileScope(file);
+        JetScope scope = fileScopeProvider.getFileScope(file);
         LazyAnnotationsContextImpl lazyAnnotationContext = new LazyAnnotationsContextImpl(annotationResolve, storageManager, trace, scope);
         return new LazyAnnotations(lazyAnnotationContext, annotationEntries);
     }
@@ -349,12 +354,6 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
         }
     }
 
-    @Override
-    @NotNull
-    public ScopeProvider getScopeProvider() {
-        return scopeProvider;
-    }
-
     @NotNull
     public JetImportsFactory getJetImportsFactory() {
         return jetImportFactory;
@@ -388,4 +387,16 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
     public FunctionDescriptorResolver getFunctionDescriptorResolver() {
         return functionDescriptorResolver;
     }
+
+    @NotNull
+    @Override
+    public DeclarationScopeProvider getDeclarationScopeProvider() {
+        return declarationScopeProvider;
+    }
+
+    @Override
+    @NotNull
+    public FileScopeProvider getFileScopeProvider() {
+        return fileScopeProvider;
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ScopeProvider.java

@@ -1,119 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.resolve.lazy;
-
-import com.intellij.psi.PsiElement;
-import kotlin.jvm.functions.Function0;
-import kotlin.jvm.functions.Function1;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
-import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetImportDirective;
-import org.jetbrains.kotlin.psi.JetImportsFactory;
-import org.jetbrains.kotlin.resolve.ImportPath;
-import org.jetbrains.kotlin.resolve.TemporaryBindingTrace;
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull;
-import org.jetbrains.kotlin.storage.NotNullLazyValue;
-
-import javax.inject.Inject;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
-public class ScopeProvider implements DeclarationScopeProvider, FileScopeProvider {
-
-    public static class AdditionalFileScopeProvider {
-        @NotNull
-        public List<JetScope> scopes(@NotNull JetFile file) {
-            return Collections.emptyList();
-        }
-    }
-
-    private final ResolveSession resolveSession;
-
-    private final NotNullLazyValue<Collection<JetImportDirective>> defaultImports;
-
-    private final MemoizedFunctionToNotNull<JetFile, LazyFileScope> fileScopes;
-
-    private AdditionalFileScopeProvider additionalFileScopeProvider;
-    private DeclarationScopeProvider declarationScopeProvider;
-
-    @Inject
-    public void setAdditionalFileScopesProvider(@NotNull AdditionalFileScopeProvider additionalFileScopeProvider) {
-        this.additionalFileScopeProvider = additionalFileScopeProvider;
-    }
-
-    @Inject
-    public void setDeclarationScopeProvider(@NotNull DeclarationScopeProviderImpl declarationScopeProvider) {
-        this.declarationScopeProvider = declarationScopeProvider;
-    }
-
-    public ScopeProvider(@NotNull final ResolveSession resolveSession) {
-        this.resolveSession = resolveSession;
-
-        this.defaultImports = resolveSession.getStorageManager().createLazyValue(new Function0<Collection<JetImportDirective>>() {
-            @Override
-            public Collection<JetImportDirective> invoke() {
-                JetImportsFactory importsFactory = resolveSession.getJetImportsFactory();
-                List<ImportPath> defaultImports = resolveSession.getModuleDescriptor().getDefaultImports();
-
-                return importsFactory.createImportDirectives(defaultImports);
-            }
-        });
-
-
-        this.fileScopes = resolveSession.getStorageManager().createMemoizedFunction(new Function1<JetFile, LazyFileScope>() {
-            @Override
-            public LazyFileScope invoke(JetFile file) {
-                return createFileScope(file);
-            }
-        });
-    }
-
-    @Override
-    @NotNull
-    public LazyFileScope getFileScope(@NotNull JetFile file) {
-        return fileScopes.invoke(file);
-    }
-
-    private LazyFileScope createFileScope(@NotNull JetFile file) {
-        TemporaryBindingTrace tempTrace = TemporaryBindingTrace.create(resolveSession.getTrace(), "Transient trace for default imports lazy resolve");
-        return LazyFileScope.Factory.create(
-                resolveSession,
-                file,
-                defaultImports.invoke(),
-                additionalFileScopeProvider.scopes(file),
-                resolveSession.getTrace(),
-                tempTrace,
-                "LazyFileScope for file " + file.getName());
-    }
-
-    @NotNull
-    @Override
-    public JetScope getResolutionScopeForDeclaration(@NotNull PsiElement elementOfDeclaration) {
-        return declarationScopeProvider.getResolutionScopeForDeclaration(elementOfDeclaration);
-    }
-
-    @NotNull
-    @Override
-    public DataFlowInfo getOuterDataFlowInfoForDeclaration(@NotNull PsiElement elementOfDeclaration) {
-        return declarationScopeProvider.getOuterDataFlowInfoForDeclaration(elementOfDeclaration);
-    }
-}

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt

@@ -18,23 +18,21 @@ package org.jetbrains.kotlin.resolve.lazy.descriptors
 
 import com.google.common.collect.Sets
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.AnnotationResolver
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.ScriptNameUtil
+import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.data.JetScriptInfo
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProvider
-import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull
-import org.jetbrains.kotlin.utils.Printer
-
-import java.util.*
 import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.toReadOnlyList
-import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
+import java.util.LinkedHashSet
 
 public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : DeclarationProvider>
 protected constructor(
@@ -76,7 +74,7 @@ protected constructor(
                     resolutionScope,
                     functionDeclaration,
                     trace,
-                    c.scopeProvider.getOuterDataFlowInfoForDeclaration(functionDeclaration)))
+                    c.declarationScopeProvider.getOuterDataFlowInfoForDeclaration(functionDeclaration)))
         }
 
         getNonDeclaredFunctions(name, result)
@@ -101,7 +99,7 @@ protected constructor(
                     resolutionScope,
                     propertyDeclaration,
                     trace,
-                    c.scopeProvider.getOuterDataFlowInfoForDeclaration(propertyDeclaration))
+                    c.declarationScopeProvider.getOuterDataFlowInfoForDeclaration(propertyDeclaration))
             result.add(propertyDescriptor)
         }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java

@@ -254,7 +254,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
 
     @NotNull
     protected JetScope getOuterScope() {
-        return c.getScopeProvider().getResolutionScopeForDeclaration(declarationProvider.getOwnerInfo().getScopeAnchor());
+        return c.getDeclarationScopeProvider().getResolutionScopeForDeclaration(declarationProvider.getOwnerInfo().getScopeAnchor());
     }
 
     @Override

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt

@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.resolve.lazy.descriptors
 
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.JetDeclaration
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.PackageMemberDeclarationProvider
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 
 public class LazyPackageMemberScope(
@@ -36,7 +36,7 @@ public class LazyPackageMemberScope(
     override fun getPackage(name: Name): PackageViewDescriptor? = null
 
     override fun getScopeForMemberDeclarationResolution(declaration: JetDeclaration)
-            = resolveSession.getScopeProvider().getFileScope(declaration.getContainingJetFile())
+            = resolveSession.getFileScopeProvider().getFileScope(declaration.getContainingJetFile())
 
     override fun getNonDeclaredFunctions(name: Name, result: MutableSet<FunctionDescriptor>) {
         // No extra functions

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt

@@ -90,7 +90,7 @@ public class LazyScriptDescriptor(
         return ChainedScope(
                 this,
                 "Scope for body resolution for " + this,
-                resolveSession.getScopeProvider().getFileScope(jetScript.getContainingJetFile()),
+                resolveSession.getFileScopeProvider().getFileScope(jetScript.getContainingJetFile()),
                 parametersScope
         )
     }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt

@@ -18,23 +18,20 @@ package org.jetbrains.kotlin.types.expressions
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
 import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.frontend.di.createContainerForLazyLocalClassifierAnalyzer
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.JetClassOrObject
 import org.jetbrains.kotlin.psi.debugText.getDebugText
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl
-import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver
+import org.jetbrains.kotlin.resolve.lazy.*
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo
 import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider
@@ -114,7 +111,7 @@ class LocalClassDescriptorHolder(
         if (classDescriptor == null) {
             classDescriptor = LazyClassDescriptor(
                     object : LazyClassContext {
-                        override val scopeProvider = declarationScopeProvider
+                        override val declarationScopeProvider = declarationScopeProvider
                         override val storageManager = this@LocalClassDescriptorHolder.storageManager
                         override val trace = expressionTypingContext.trace
                         override val moduleDescriptor = this@LocalClassDescriptorHolder.moduleDescriptor
@@ -167,8 +164,9 @@ class LocalLazyDeclarationResolver(
 
 class DeclarationScopeProviderForLocalClassifierAnalyzer(
         lazyDeclarationResolver: LazyDeclarationResolver,
+        fileScopeProvider: FileScopeProvider,
         val localClassDescriptorManager: LocalClassDescriptorHolder
-) : DeclarationScopeProviderImpl(lazyDeclarationResolver) {
+) : DeclarationScopeProviderImpl(lazyDeclarationResolver, fileScopeProvider) {
     override fun getResolutionScopeForDeclaration(elementOfDeclaration: PsiElement): JetScope {
         if (localClassDescriptorManager.isMyClass(elementOfDeclaration)) {
             return localClassDescriptorManager.getResolutionScopeForClass(elementOfDeclaration as JetClassOrObject)