[FIR] Inherit FirContainingNamesAwareScope from FirScope

This is needed to simplify FirScope hierarchy, because in fact all inheritors of `FirContainingNamesAwareScope` were inheritors of `FirScope` too
2021-09-28 12:53:32 +03:00
parent f3a9d70eb6
commit 9bfa6c54b8
20 changed files with 32 additions and 39 deletions
@@ -199,8 +199,8 @@ internal class KtFirScopeProvider(
    }
 }

-private class KtFirDelegatingScopeImpl<S>(
+private class KtFirDelegatingScopeImpl<S : FirContainingNamesAwareScope>(
    override val firScope: S,
    builder: KtSymbolByFirBuilder,
    token: ValidityToken
-) : KtFirDelegatingScope<S>(builder, token), ValidityTokenOwner where S : FirContainingNamesAwareScope, S : FirScope
+) : KtFirDelegatingScope<S>(builder, token), ValidityTokenOwner
@@ -21,10 +21,10 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.name.Name

-internal abstract class KtFirDelegatingScope<S>(
+internal abstract class KtFirDelegatingScope<S : FirContainingNamesAwareScope>(
    private val builder: KtSymbolByFirBuilder,
    final override val token: ValidityToken
-) : KtScope where S : FirContainingNamesAwareScope, S : FirScope {
+) : KtScope {

    abstract val firScope: S

@@ -79,11 +79,11 @@ internal fun FirScope.getCallableSymbols(callableNames: Collection<Name>, builde
    }
 }

-internal class KtFirDelegatingScopeImpl<S>(
+internal class KtFirDelegatingScopeImpl<S : FirContainingNamesAwareScope>(
    override val firScope: S,
    builder: KtSymbolByFirBuilder,
    token: ValidityToken
-) : KtFirDelegatingScope<S>(builder, token) where S : FirContainingNamesAwareScope, S : FirScope
+) : KtFirDelegatingScope<S>(builder, token)


 internal fun FirScope.getClassifierSymbols(classLikeNames: Collection<Name>, builder: KtSymbolByFirBuilder): Sequence<KtClassifierSymbol> =
@@ -104,4 +104,4 @@ internal fun FirScope.getConstructors(builder: KtSymbolByFirBuilder): Sequence<K
            constructorSymbols.add(builder.functionLikeBuilder.buildConstructorSymbol(firSymbol.fir))
        }
        yieldAll(constructorSymbols)
-    }
+    }
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.java.enhancement.FirSignatureEnhancement
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
-import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.Name

@@ -17,7 +16,7 @@ class JavaClassStaticEnhancementScope(
    session: FirSession,
    owner: FirRegularClassSymbol,
    private val useSiteStaticScope: JavaClassStaticUseSiteScope,
-) : FirScope(), FirContainingNamesAwareScope {
+) : FirContainingNamesAwareScope() {
    private val signatureEnhancement = FirSignatureEnhancement(owner.fir, session) {
        emptyList()
    }
@@ -22,7 +22,7 @@ class JavaClassStaticUseSiteScope internal constructor(
    private val superClassScope: FirScope,
    private val superTypesScopes: List<FirScope>,
    javaTypeParameterStack: JavaTypeParameterStack,
-) : FirScope(), FirContainingNamesAwareScope {
+) : FirContainingNamesAwareScope() {
    private val functions = hashMapOf<Name, Collection<FirNamedFunctionSymbol>>()
    private val properties = hashMapOf<Name, Collection<FirVariableSymbol<*>>>()
    private val overrideChecker = JavaOverrideChecker(session, javaTypeParameterStack)
@@ -38,7 +38,7 @@ class FirSyntheticFunctionSymbol(
 class FirSyntheticPropertiesScope(
    val session: FirSession,
    private val baseScope: FirTypeScope
-) : FirScope(), FirContainingNamesAwareScope {
+) : FirContainingNamesAwareScope() {
    private val syntheticNamesProvider = session.syntheticNamesProvider

    override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) {
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.name.Name

-abstract class FirTypeParameterScope : FirScope(), FirContainingNamesAwareScope {
+abstract class FirTypeParameterScope : FirContainingNamesAwareScope() {
    abstract val typeParameters: Map<Name, List<FirTypeParameter>>

    override fun processClassifiersByNameWithSubstitution(
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames

-abstract class FirClassDeclaredMemberScope : FirScope(), FirContainingNamesAwareScope
+abstract class FirClassDeclaredMemberScope : FirContainingNamesAwareScope()

 class FirClassDeclaredMemberScopeImpl(
    val useSiteSession: FirSession,
@@ -33,7 +33,7 @@ class FirDelegatedMemberScope(
    private val containingClass: FirClass,
    private val declaredMemberScope: FirScope,
    private val delegateFields: List<FirField>,
-) : FirScope(), FirContainingNamesAwareScope {
+) : FirContainingNamesAwareScope() {
    private val dispatchReceiverType = containingClass.defaultType()
    private val overrideChecker = FirStandardOverrideChecker(session)

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
-import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -20,7 +19,7 @@ class FirLazyNestedClassifierScope(
    val classId: ClassId,
    private val existingNames: List<Name>,
    private val symbolProvider: FirSymbolProvider
-) : FirScope(), FirContainingNamesAwareScope {
+) : FirContainingNamesAwareScope() {
    override fun processClassifiersByNameWithSubstitution(
        name: Name,
        processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
-import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -26,7 +25,7 @@ class FirLocalScope private constructor(
    val properties: PersistentMap<Name, FirVariableSymbol<*>>,
    val functions: PersistentMultimap<Name, FirNamedFunctionSymbol>,
    val classes: PersistentMap<Name, FirRegularClassSymbol>
-) : FirScope(), FirContainingNamesAwareScope {
+) : FirContainingNamesAwareScope() {
    constructor() : this(persistentMapOf(), PersistentMultimap(), persistentMapOf())

    fun storeClass(klass: FirRegularClass): FirLocalScope {
@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
-import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -21,7 +20,7 @@ import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.name.Name

-abstract class FirNestedClassifierScope(val klass: FirClass, val useSiteSession: FirSession) : FirScope(), FirContainingNamesAwareScope {
+abstract class FirNestedClassifierScope(val klass: FirClass, val useSiteSession: FirSession) : FirContainingNamesAwareScope() {
    protected abstract fun getNestedClassSymbol(name: Name): FirRegularClassSymbol?

    override fun processClassifiersByNameWithSubstitution(
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.name.Name
 private class FirNestedClassifierScopeWithSubstitution(
    private val scope: FirScope,
    private val substitutor: ConeSubstitutor
-) : FirScope(), FirContainingNamesAwareScope {
+) : FirContainingNamesAwareScope() {

    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
        scope.processFunctionsByName(name, processor)
@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.builder.buildPropertyCopy
 import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunctionCopy
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
-import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
@@ -24,7 +23,7 @@ import org.jetbrains.kotlin.name.Name
 class FirObjectImportedCallableScope(
    private val importedClassId: ClassId,
    private val objectUseSiteScope: FirTypeScope
-) : FirScope(), FirContainingNamesAwareScope {
+) : FirContainingNamesAwareScope() {
    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
        objectUseSiteScope.processFunctionsByName(name) wrapper@{ symbol ->
            val function = symbol.fir
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name

-class FirOnlyCallablesScope(val delegate: FirScope) : FirScope(), FirContainingNamesAwareScope {
+class FirOnlyCallablesScope(val delegate: FirScope) : FirContainingNamesAwareScope() {
    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
        return delegate.processFunctionsByName(name, processor)
    }
@@ -27,4 +27,4 @@ class FirOnlyCallablesScope(val delegate: FirScope) : FirScope(), FirContainingN
    override fun getCallableNames(): Set<Name> = delegate.getContainingCallableNamesIfPresent()

    override fun getClassifierNames(): Set<Name> = emptySet()
-}
+}
@@ -8,12 +8,11 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.getContainingCallableNamesIfPresent
 import org.jetbrains.kotlin.fir.scopes.getContainingClassifierNamesIfPresent
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.name.Name

-class FirOnlyClassifiersScope(val delegate: FirScope) : FirScope() , FirContainingNamesAwareScope {
+class FirOnlyClassifiersScope(val delegate: FirScope) : FirContainingNamesAwareScope() {
    override fun processClassifiersByNameWithSubstitution(name: Name, processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit) {
        return delegate.processClassifiersByNameWithSubstitution(name, processor)
    }
@@ -21,4 +20,4 @@ class FirOnlyClassifiersScope(val delegate: FirScope) : FirScope() , FirContaini
    override fun getCallableNames(): Set<Name> = emptySet()

    override fun getClassifierNames(): Set<Name> = delegate.getContainingClassifierNamesIfPresent()
-}
+}
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name

-class FirStaticScope(private val delegateScope: FirScope) : FirScope(), FirContainingNamesAwareScope {
+class FirStaticScope(private val delegateScope: FirScope) : FirContainingNamesAwareScope() {
    override fun processClassifiersByNameWithSubstitution(name: Name, processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit) {
        delegateScope.processClassifiersByNameWithSubstitution(name, processor)
    }
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name

-class FirCompositeScope(val scopes: Iterable<FirScope>) : FirScope(), FirContainingNamesAwareScope {
+class FirCompositeScope(val scopes: Iterable<FirScope>) : FirContainingNamesAwareScope() {

    override fun processClassifiersByNameWithSubstitution(
        name: Name,
@@ -5,15 +5,14 @@

 package org.jetbrains.kotlin.fir.scopes

-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name

-interface FirContainingNamesAwareScope {
-    fun getCallableNames(): Set<Name>
+abstract class FirContainingNamesAwareScope : FirScope() {
+    abstract fun getCallableNames(): Set<Name>

-    fun getClassifierNames(): Set<Name>
+    abstract fun getClassifierNames(): Set<Name>
 }

 fun FirScope.getContainingCallableNamesIfPresent(): Set<Name> =
@@ -22,19 +21,19 @@ fun FirScope.getContainingCallableNamesIfPresent(): Set<Name> =
 fun FirScope.getContainingClassifierNamesIfPresent(): Set<Name> =
    if (this is FirContainingNamesAwareScope) getClassifierNames() else emptySet()

-fun <S> S.processAllFunctions(processor: (FirNamedFunctionSymbol) -> Unit) where S : FirScope, S : FirContainingNamesAwareScope {
+fun FirContainingNamesAwareScope.processAllFunctions(processor: (FirNamedFunctionSymbol) -> Unit) {
    for (name in getCallableNames()) {
        processFunctionsByName(name, processor)
    }
 }

-fun <S> S.processAllProperties(processor: (FirVariableSymbol<*>) -> Unit) where S : FirScope, S : FirContainingNamesAwareScope {
+fun FirContainingNamesAwareScope.processAllProperties(processor: (FirVariableSymbol<*>) -> Unit) {
    for (name in getCallableNames()) {
        processPropertiesByName(name, processor)
    }
 }

-fun <S> S.collectAllProperties(): Collection<FirVariableSymbol<*>> where S : FirScope, S : FirContainingNamesAwareScope {
+fun FirContainingNamesAwareScope.collectAllProperties(): Collection<FirVariableSymbol<*>> {
    return mutableListOf<FirVariableSymbol<*>>().apply {
        processAllProperties(this::add)
    }
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.name.Name

-abstract class FirTypeScope : FirScope(), FirContainingNamesAwareScope {
+abstract class FirTypeScope : FirContainingNamesAwareScope() {
    // If the scope instance is the same as the one from which the symbol was originated, this function supplies
    // all direct overridden members (each of them comes a base scope where grand-parents [overridden of this overridden] may be obtained from)
    //
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.name.Name
 class FirUnstableSmartcastTypeScope(
    private val smartcastScope: FirTypeScope,
    private val originalScope: FirTypeScope
-) : FirTypeScope(), FirContainingNamesAwareScope {
+) : FirTypeScope() {
    private val scopes = listOf(originalScope, smartcastScope)
    private val symbolsFromUnstableSmartcast = mutableSetOf<FirCallableSymbol<*>>()
    override fun processClassifiersByNameWithSubstitution(