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 DeclarationScopeProviderImpl(
-    public void setFileScopeProvider(@NotNull FileScopeProvider fileScopeProvider) {
+            @NotNull LazyDeclarationResolver lazyDeclarationResolver,
-        this.fileScopeProvider = fileScopeProvider;
+            @NotNull FileScopeProvider fileScopeProvider
-    }
+    ) {
-
-    public DeclarationScopeProviderImpl(@NotNull LazyDeclarationResolver lazyDeclarationResolver) {
         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 {
+public interface FileScopeProvider {
-    fun getFileScope(jetFile: JetFile): JetScope
+    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 java.util.LinkedHashSet
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
 
 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.*
-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.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)

idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt

@@ -16,17 +16,15 @@
 
 package org.jetbrains.kotlin.resolve.lazy
 
-import com.google.common.base.Function
-import com.google.common.base.Functions
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analyzer.computeTypeInContext
 import org.jetbrains.kotlin.cfg.JetFlowInformationProvider
+import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.SimpleGlobalContext
 import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.frontend.di.createContainerForBodyResolve
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -40,8 +38,6 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.storage.LockBasedLazyResolveStorageManager
-import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.DynamicTypesSettings
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
@@ -138,7 +134,7 @@ public abstract class ElementResolver protected constructor(
             is JetInitializerList -> delegationSpecifierAdditionalResolve(resolveSession, resolveElement, resolveElement.getParent() as JetEnumEntry, file)
 
             is JetImportDirective -> {
-                val scope = resolveSession.getScopeProvider().getFileScope(resolveElement.getContainingJetFile())
+                val scope = resolveSession.getFileScopeProvider().getFileScope(resolveElement.getContainingJetFile())
                 scope.forceResolveAllImports()
                 resolveSession.getTrace()
             }
@@ -237,7 +233,7 @@ public abstract class ElementResolver protected constructor(
 
         if (scopeForContextElement == null) return trace
 
-        val codeFragmentScope = resolveSession.getScopeProvider().getFileScope(codeFragment)
+        val codeFragmentScope = resolveSession.getFileScopeProvider().getFileScope(codeFragment)
         val chainedScope = ChainedScope(scopeForContextElement.getContainingDeclaration(),
                                         "Scope for resolve code fragment", scopeForContextElement, codeFragmentScope)
 
@@ -323,7 +319,7 @@ public abstract class ElementResolver protected constructor(
 
     private fun propertyAdditionalResolve(resolveSession: ResolveSession, jetProperty: JetProperty, file: JetFile, statementFilter: StatementFilter): BindingTrace {
         val trace = createDelegatingTrace(jetProperty)
-        val propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty)
+        val propertyResolutionScope = resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(jetProperty)
 
         val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter)
         val descriptor = resolveSession.resolveToDescriptor(jetProperty) as PropertyDescriptor
@@ -341,7 +337,7 @@ public abstract class ElementResolver protected constructor(
 
         val bodyResolveContext = BodyResolveContextForLazy(TopDownAnalysisMode.LocalDeclarations, { declaration ->
             assert(declaration.getParent() == jetProperty) { "Must be called only for property accessors, but called for $declaration" }
-            resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration)
+            resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(declaration)
         })
 
         bodyResolver.resolvePropertyAccessors(bodyResolveContext, jetProperty, descriptor)
@@ -356,7 +352,7 @@ public abstract class ElementResolver protected constructor(
     private fun functionAdditionalResolve(resolveSession: ResolveSession, namedFunction: JetNamedFunction, file: JetFile, statementFilter: StatementFilter): BindingTrace {
         val trace = createDelegatingTrace(namedFunction)
 
-        val scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(namedFunction)
+        val scope = resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(namedFunction)
         val functionDescriptor = resolveSession.resolveToDescriptor(namedFunction) as FunctionDescriptor
         ForceResolveUtil.forceResolveAllContents(functionDescriptor)
 
@@ -369,7 +365,7 @@ public abstract class ElementResolver protected constructor(
     private fun secondaryConstructorAdditionalResolve(resolveSession: ResolveSession, constructor: JetSecondaryConstructor, file: JetFile, statementFilter: StatementFilter): BindingTrace {
         val trace = createDelegatingTrace(constructor)
 
-        val scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(constructor)
+        val scope = resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(constructor)
         val constructorDescriptor = resolveSession.resolveToDescriptor(constructor) as ConstructorDescriptor
         ForceResolveUtil.forceResolveAllContents(constructorDescriptor)
 
@@ -381,7 +377,7 @@ public abstract class ElementResolver protected constructor(
 
     private fun constructorAdditionalResolve(resolveSession: ResolveSession, klass: JetClass, file: JetFile, statementFilter: StatementFilter): BindingTrace {
         val trace = createDelegatingTrace(klass)
-        val scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(klass)
+        val scope = resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(klass)
 
         val classDescriptor = resolveSession.resolveToDescriptor(klass) as ClassDescriptor
         val constructorDescriptor = classDescriptor.getUnsubstitutedPrimaryConstructor()
@@ -420,12 +416,11 @@ public abstract class ElementResolver protected constructor(
     }
 
     private fun getExpressionResolutionScope(resolveSession: ResolveSession, expression: JetExpression): JetScope {
-        val provider = resolveSession.getScopeProvider()
         val parentDeclaration = expression.getParentOfType<JetDeclaration>(true)
         if (parentDeclaration == null) {
-            return provider.getFileScope(expression.getContainingJetFile())
+            return resolveSession.getFileScopeProvider().getFileScope(expression.getContainingJetFile())
         }
-        return provider.getResolutionScopeForDeclaration(parentDeclaration)
+        return resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(parentDeclaration)
     }
 
     private fun getExpressionMemberScope(resolveSession: ResolveSession, expression: JetExpression): JetScope? {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt

@@ -222,7 +222,7 @@ private class ResolutionFacadeImpl(private val project: Project, private val cac
     }
 
     override fun getFileTopLevelScope(file: JetFile): JetScope {
-        return cache.getLazyResolveSession(file).getScopeProvider().getFileScope(file)
+        return cache.getLazyResolveSession(file).getFileScopeProvider().getFileScope(file)
     }
 
     override fun resolveImportReference(moduleDescriptor: ModuleDescriptor, fqName: FqName): Collection<DeclarationDescriptor> {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt

@@ -29,11 +29,11 @@ import com.intellij.util.containers.SLRUCache
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.analyzer.analyzeInContext
 import org.jetbrains.kotlin.asJava.LightClassUtil
+import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.SimpleGlobalContext
 import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.frontend.di.createContainerForLazyBodyResolve
 import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
@@ -299,7 +299,7 @@ private object KotlinResolveDataProvider {
 
         if (scopeForContextElement == null) return BindingContext.EMPTY
 
-        val codeFragmentScope = resolveSession.getScopeProvider().getFileScope(codeFragment)
+        val codeFragmentScope = resolveSession.getFileScopeProvider().getFileScope(codeFragment)
         val chainedScope = ChainedScope(
                                 scopeForContextElement.getContainingDeclaration(),
                                 "Scope for resolve code fragment",

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveSessionForBodies.java

@@ -26,12 +26,9 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
 import org.jetbrains.kotlin.resolve.BodyResolveCache;
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
+import org.jetbrains.kotlin.resolve.lazy.*;
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor;
 import org.jetbrains.kotlin.storage.ExceptionTracker;
 import org.jetbrains.kotlin.storage.StorageManager;
@@ -119,10 +116,16 @@ public class ResolveSessionForBodies implements KotlinCodeAnalyzer {
         return resolveSession.getScriptDescriptor(script);
     }
 
-    @Override
     @NotNull
-    public ScopeProvider getScopeProvider() {
+    @Override
-        return resolveSession.getScopeProvider();
+    public DeclarationScopeProvider getDeclarationScopeProvider() {
+        return resolveSession.getDeclarationScopeProvider();
+    }
+
+    @NotNull
+    @Override
+    public FileScopeProvider getFileScopeProvider() {
+        return resolveSession.getFileScopeProvider();
     }
 
     @NotNull

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

@@ -26,8 +26,8 @@ import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.BodyResolveCache
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
+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
 import org.jetbrains.kotlin.types.DynamicTypesAllowed
 
@@ -40,8 +40,8 @@ public fun createTopDownAnalyzerForJs(
         configureModule(moduleContext, KotlinJsCheckerProvider, bindingTrace)
 
         useInstance(declarationProviderFactory)
+        useImpl<FileScopeProviderImpl>()
         useInstance(BodyResolveCache.ThrowException)
-        useImpl<ScopeProvider>()
         useImpl<ResolveSession>()
         useImpl<LazyTopDownAnalyzerForTopLevel>()
         useImpl<DynamicTypesAllowed>()