From 980a0d19be5683790276c872c096adbf7949e082 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 18 May 2015 15:03:45 +0300 Subject: [PATCH] Refactoring: don't register scopes explicitly, get them from scope provider on demand --- .../kotlin/cli/jvm/repl/ReplInterpreter.java | 3 ++- .../kotlin/resolve/BodiesResolveContext.java | 5 +++-- .../kotlin/resolve/BodyResolver.java | 8 +++---- .../kotlin/resolve/LazyTopDownAnalyzer.kt | 14 +----------- .../resolve/TopDownAnalysisContext.java | 22 ++++++++++--------- .../kotlin/resolve/lazy/ElementResolver.kt | 15 +++++-------- 6 files changed, 28 insertions(+), 39 deletions(-) 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 eaceaf3d4cd..dbe14f75cc9 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 @@ -127,7 +127,8 @@ public class ReplInterpreter { scopeProvider ); - this.topDownAnalysisContext = new TopDownAnalysisContext(TopDownAnalysisMode.LocalDeclarations, DataFlowInfo.EMPTY); + this.topDownAnalysisContext = new TopDownAnalysisContext(TopDownAnalysisMode.LocalDeclarations, DataFlowInfo.EMPTY, + container.getResolveSession().getScopeProvider()); this.topDownAnalyzer = container.getLazyTopDownAnalyzerForTopLevel(); this.resolveSession = container.getResolveSession(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java index b3670ef13d4..5f6bb6bfc04 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java @@ -16,9 +16,9 @@ package org.jetbrains.kotlin.resolve; -import com.google.common.base.Function; import org.jetbrains.annotations.Mutable; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.ReadOnly; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.psi.*; @@ -46,7 +46,8 @@ public interface BodiesResolveContext { @Mutable Map getFunctions(); - Function getDeclaringScopes(); + @Nullable + JetScope getDeclaringScope(@NotNull JetDeclaration declaration); @NotNull DataFlowInfo getOuterDataFlowInfo(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index 5d7267295cf..980badff39c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java @@ -144,7 +144,7 @@ public class BodyResolver { private void resolveSecondaryConstructors(@NotNull BodiesResolveContext c) { for (Map.Entry entry : c.getSecondaryConstructors().entrySet()) { - JetScope declaringScope = c.getDeclaringScopes().apply(entry.getKey()); + JetScope declaringScope = c.getDeclaringScope(entry.getKey()); assert declaringScope != null : "Declaring scope should be registered before body resolve"; resolveSecondaryConstructorBody(c.getOuterDataFlowInfo(), trace, entry.getKey(), entry.getValue(), declaringScope); } @@ -633,7 +633,7 @@ public class BodyResolver { } private JetScope makeScopeForPropertyAccessor(@NotNull BodiesResolveContext c, @NotNull JetPropertyAccessor accessor, @NotNull PropertyDescriptor descriptor) { - JetScope accessorDeclaringScope = c.getDeclaringScopes().apply(accessor); + JetScope accessorDeclaringScope = c.getDeclaringScope(accessor); assert accessorDeclaringScope != null : "Scope for accessor " + accessor.getText() + " should exists"; return JetScopeUtils.makeScopeForPropertyAccessor(descriptor, accessorDeclaringScope, trace); } @@ -737,7 +737,7 @@ public class BodyResolver { @NotNull private static JetScope getScopeForProperty(@NotNull BodiesResolveContext c, @NotNull JetProperty property) { - JetScope scope = c.getDeclaringScopes().apply(property); + JetScope scope = c.getDeclaringScope(property); assert scope != null : "Scope for property " + property.getText() + " should exists"; return scope; } @@ -749,7 +749,7 @@ public class BodyResolver { computeDeferredType(descriptor.getReturnType()); - JetScope declaringScope = c.getDeclaringScopes().apply(declaration); + JetScope declaringScope = c.getDeclaringScope(declaration); assert declaringScope != null; resolveFunctionBody(c.getOuterDataFlowInfo(), trace, declaration, descriptor, declaringScope); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt index 58abc341513..4bdb281a73d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt @@ -103,7 +103,7 @@ public class LazyTopDownAnalyzer { } public fun analyzeDeclarations(topDownAnalysisMode: TopDownAnalysisMode, declarations: Collection, outerDataFlowInfo: DataFlowInfo): TopDownAnalysisContext { - val c = TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo) + val c = TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo, declarationScopeProvider!!) val topLevelFqNames = HashMultimap.create() @@ -199,7 +199,6 @@ public class LazyTopDownAnalyzer { override fun visitSecondaryConstructor(constructor: JetSecondaryConstructor) { c.getSecondaryConstructors().put(constructor, lazyDeclarationResolver!!.resolveToDescriptor(constructor) as ConstructorDescriptor) - registerScope(c, constructor) } override fun visitEnumEntry(enumEntry: JetEnumEntry) { @@ -211,7 +210,6 @@ public class LazyTopDownAnalyzer { } override fun visitAnonymousInitializer(initializer: JetClassInitializer) { - registerScope(c, initializer) val classOrObject = PsiTreeUtil.getParentOfType(initializer, javaClass()) c.getAnonymousInitializers().put(initializer, lazyDeclarationResolver!!.resolveToDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes) } @@ -269,10 +267,6 @@ public class LazyTopDownAnalyzer { c.getProperties().put(property, descriptor) ForceResolveUtil.forceResolveAllContents(descriptor.getAnnotations()) registerTopLevelFqName(topLevelFqNames, property, descriptor) - - registerScope(c, property) - registerScope(c, property.getGetter()) - registerScope(c, property.getSetter()) } } @@ -284,15 +278,9 @@ public class LazyTopDownAnalyzer { for (parameterDescriptor in simpleFunctionDescriptor.getValueParameters()) { ForceResolveUtil.forceResolveAllContents(parameterDescriptor.getAnnotations()) } - registerScope(c, function) } } - private fun registerScope(c: TopDownAnalysisContext, declaration: JetDeclaration?) { - if (declaration == null) return - c.registerDeclaringScope(declaration, declarationScopeProvider!!.getResolutionScopeForDeclaration(declaration)) - } - private fun registerTopLevelFqName(topLevelFqNames: Multimap, declaration: JetNamedDeclaration, descriptor: DeclarationDescriptor) { if (DescriptorUtils.isTopLevelDeclaration(descriptor)) { val fqName = declaration.getFqName() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java index 395954c5eee..46f4d28d964 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java @@ -16,15 +16,15 @@ package org.jetbrains.kotlin.resolve; -import com.google.common.base.Function; -import com.google.common.base.Functions; import com.google.common.collect.Maps; import kotlin.KotlinPackage; import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; +import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider; import org.jetbrains.kotlin.resolve.scopes.JetScope; import java.io.PrintStream; @@ -42,7 +42,6 @@ public class TopDownAnalysisContext implements BodiesResolveContext { private final Set files = new LinkedHashSet(); private final Map secondaryConstructors = Maps.newLinkedHashMap(); - private final Map declaringScopes = Maps.newHashMap(); private final Map functions = Maps.newLinkedHashMap(); private final Map properties = Maps.newLinkedHashMap(); private final Map primaryConstructorParameterProperties = Maps.newHashMap(); @@ -51,12 +50,18 @@ public class TopDownAnalysisContext implements BodiesResolveContext { private final Map scripts = Maps.newLinkedHashMap(); private final TopDownAnalysisMode topDownAnalysisMode; + private final DeclarationScopeProvider declarationScopeProvider; private StringBuilder debugOutput; - public TopDownAnalysisContext(@NotNull TopDownAnalysisMode topDownAnalysisMode, @NotNull DataFlowInfo outerDataFlowInfo) { + public TopDownAnalysisContext( + @NotNull TopDownAnalysisMode topDownAnalysisMode, + @NotNull DataFlowInfo outerDataFlowInfo, + @NotNull DeclarationScopeProvider declarationScopeProvider + ) { this.topDownAnalysisMode = topDownAnalysisMode; this.outerDataFlowInfo = outerDataFlowInfo; + this.declarationScopeProvider = declarationScopeProvider; } @Override @@ -123,13 +128,10 @@ public class TopDownAnalysisContext implements BodiesResolveContext { return properties; } + @Nullable @Override - public Function getDeclaringScopes() { - return Functions.forMap(declaringScopes); - } - - public void registerDeclaringScope(@NotNull JetDeclaration declaration, @NotNull JetScope scope) { - declaringScopes.put(declaration, scope); + public JetScope getDeclaringScope(@NotNull JetDeclaration declaration) { + return declarationScopeProvider.getResolutionScopeForDeclaration(declaration); } @Override 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 8e354abdbee..0bacfb9e873 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 @@ -319,11 +319,9 @@ public abstract class ElementResolver protected constructor( bodyResolver.resolvePropertyDelegate(DataFlowInfo.EMPTY, jetProperty, descriptor, propertyDelegate, propertyResolutionScope, propertyResolutionScope) } - val bodyResolveContext = BodyResolveContextForLazy(TopDownAnalysisMode.LocalDeclarations, object : Function { - override fun apply(declaration: JetDeclaration?): JetScope? { - assert(declaration!!.getParent() == jetProperty) { "Must be called only for property accessors, but called for " + declaration } - return resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration) - } + 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) }) bodyResolver.resolvePropertyAccessors(bodyResolveContext, jetProperty, descriptor) @@ -446,9 +444,8 @@ public abstract class ElementResolver protected constructor( private class BodyResolveContextForLazy( private val topDownAnalysisMode: TopDownAnalysisMode, - private val declaringScopes: Function + private val declaringScopes: Function1 ) : BodiesResolveContext { - override fun getFiles(): Collection = setOf() override fun getDeclaredClasses(): Map = mapOf() @@ -461,11 +458,11 @@ public abstract class ElementResolver protected constructor( override fun getFunctions(): Map = mapOf() - override fun getDeclaringScopes() = declaringScopes as Function + override fun getDeclaringScope(declaration: JetDeclaration): JetScope? = declaringScopes(declaration) override fun getScripts(): Map = mapOf() - override fun getOuterDataFlowInfo() = DataFlowInfo.EMPTY + override fun getOuterDataFlowInfo(): DataFlowInfo = DataFlowInfo.EMPTY override fun getTopDownAnalysisMode() = topDownAnalysisMode }