From b173f96505d691e72dbb2881d7b2e124030f503a Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Mon, 29 Jun 2015 17:34:38 +0300 Subject: [PATCH] Refactor: Remove ScopeProvider, introduce FileScopeProviderImpl Rename NoFileScopeProvider -> FileScopeProvider.ThrowException, ScopeProvider.AdditionalScopeProvider -> FileScopeProvider.AdditionalScopes --- .../kotlin/cli/jvm/repl/ReplInterpreter.java | 6 +- .../kotlin/cli/jvm/repl/di/injection.kt | 7 +- .../kotlin/frontend/java/di/injection.kt | 6 +- .../jetbrains/kotlin/frontend/di/injection.kt | 6 +- .../LazyTopDownAnalyzerForTopLevel.java | 2 +- .../lazy/DeclarationScopeProviderImpl.java | 15 +-- .../kotlin/resolve/lazy/FileScopeProvider.kt | 21 ++-- .../resolve/lazy/FileScopeProviderImpl.kt | 44 +++++++ .../resolve/lazy/KotlinCodeAnalyzer.java | 9 +- .../kotlin/resolve/lazy/LazyClassContext.kt | 4 +- .../kotlin/resolve/lazy/LazyImportScope.kt | 5 +- .../kotlin/resolve/lazy/ResolveSession.java | 39 +++--- .../kotlin/resolve/lazy/ScopeProvider.java | 119 ------------------ .../descriptors/AbstractLazyMemberScope.kt | 18 ++- .../lazy/descriptors/LazyClassDescriptor.java | 2 +- .../descriptors/LazyPackageMemberScope.kt | 4 +- .../lazy/descriptors/LazyScriptDescriptor.kt | 2 +- .../expressions/LocalClassifierAnalyzer.kt | 12 +- .../kotlin/resolve/lazy/ElementResolver.kt | 25 ++-- .../idea/caches/resolve/KotlinCacheService.kt | 2 +- .../idea/caches/resolve/KotlinResolveCache.kt | 4 +- .../idea/project/ResolveSessionForBodies.java | 19 +-- .../kotlin/frontend/js/di/injection.kt | 4 +- 23 files changed, 154 insertions(+), 221 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt delete mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ScopeProvider.java diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java index dbe14f75cc9..bce8243b71c 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java +++ b/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 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(); diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt index 9100b2c5905..fab6bb69af9 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt +++ b/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() + useImpl() useImpl() }.let { it.get().initialize() diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt index eb01343a7ec..83aa1d5826a 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt +++ b/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() + useImpl() useImpl() }.let { it.javaAnalysisInit() @@ -98,7 +98,7 @@ public fun createContainerForTopDownAnalyzerForJvm( useInstance(BodyResolveCache.ThrowException) useImpl() - useImpl() + useImpl() }.let { it.javaAnalysisInit() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt index fce022e6871..c4f678bcaf8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt +++ b/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() @@ -94,8 +94,8 @@ public fun createContainerForLazyLocalClassifierAnalyzer( useImpl() useInstance(NoTopLevelDescriptorProvider) - useInstance(NoFileScopeProvider) useInstance(BodyResolveCache.ThrowException) + useInstance(FileScopeProvider.ThrowException) useImpl() useImpl() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java index 9558f4eddbe..4f7a08dfd1b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java +++ b/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(); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProviderImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProviderImpl.java index 3880b6acc6b..276a3e771f7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProviderImpl.java +++ b/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 diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt index 7c245aac4fd..03e916e2f31 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt +++ b/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 { + return emptyList() + } + } } -public object NoFileScopeProvider : FileScopeProvider { - override fun getFileScope(jetFile: JetFile): JetScope { - throw UnsupportedOperationException("Should not be called") - } -} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt new file mode 100644 index 00000000000..55931fda2d0 --- /dev/null +++ b/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() + ) + } +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/KotlinCodeAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/KotlinCodeAnalyzer.java index 2ec9f59d433..8b643cf9a16 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/KotlinCodeAnalyzer.java +++ b/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. diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt index d065190ae6e..1bf4105b137 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt +++ b/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 diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt index 71c6d9d93e9..e63d88e8f73 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt +++ b/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) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java index 3f7c5aa7df8..bfe286bb530 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java @@ -64,8 +64,6 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { private final MemoizedFunctionToNotNull fileAnnotations; private final MemoizedFunctionToNotNull 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 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; + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ScopeProvider.java deleted file mode 100644 index 2773f50e583..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ScopeProvider.java +++ /dev/null @@ -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 scopes(@NotNull JetFile file) { - return Collections.emptyList(); - } - } - - private final ResolveSession resolveSession; - - private final NotNullLazyValue> defaultImports; - - private final MemoizedFunctionToNotNull 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>() { - @Override - public Collection invoke() { - JetImportsFactory importsFactory = resolveSession.getJetImportsFactory(); - List defaultImports = resolveSession.getModuleDescriptor().getDefaultImports(); - - return importsFactory.createImportDirectives(defaultImports); - } - }); - - - this.fileScopes = resolveSession.getStorageManager().createMemoizedFunction(new Function1() { - @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); - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt index 976be2eabbc..0346754dba1 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt +++ b/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 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) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java index e9a997ae7c0..c6d1f72fd60 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/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 diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt index f82b46c805f..91686d68a36 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt +++ b/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) { // No extra functions diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt index 00003d043a9..4fd8535d455 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt +++ b/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 ) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt index c410eb7ea6e..242c0f514e3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt +++ b/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) diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt index d3858aab7c8..eb253798cf4 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt +++ b/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(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? { diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt index 9d04811a084..d3c016855c9 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt +++ b/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 { diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt index eeecec9877e..b4d824fadd7 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt +++ b/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", diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveSessionForBodies.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveSessionForBodies.java index 8147145ffb6..169fe35f5b7 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveSessionForBodies.java +++ b/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.lazy.KotlinCodeAnalyzer; -import org.jetbrains.kotlin.resolve.lazy.ResolveSession; -import org.jetbrains.kotlin.resolve.lazy.ScopeProvider; +import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver; +import org.jetbrains.kotlin.resolve.lazy.*; 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() { - return resolveSession.getScopeProvider(); + @Override + public DeclarationScopeProvider getDeclarationScopeProvider() { + return resolveSession.getDeclarationScopeProvider(); + } + + @NotNull + @Override + public FileScopeProvider getFileScopeProvider() { + return resolveSession.getFileScopeProvider(); } @NotNull diff --git a/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt b/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt index cdf9b23df63..e49687a9ce8 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt +++ b/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() useInstance(BodyResolveCache.ThrowException) - useImpl() useImpl() useImpl() useImpl()