FIR: Prepare refactoring of phasedFir

- Rename PhasedFirFileResolver -> FirPhaseManager - Move semantically significant parts to a component
2020-08-26 10:11:19 +03:00
parent 7fe02238ea
commit 2529f541ba
5 changed files with 53 additions and 44 deletions
@@ -7,12 +7,16 @@ package org.jetbrains.kotlin.fir.resolve.transformers

 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
+import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol

-abstract class PhasedFirFileResolver : FirSessionComponent {
-    abstract fun resolveDeclaration(declaration: FirDeclaration, fromPhase: FirResolvePhase, toPhase: FirResolvePhase)
+abstract class FirPhaseManager : FirSessionComponent {
+    abstract fun <D> ensureResolved(
+        symbol: AbstractFirBasedSymbol<D>,
+        requiredPhase: FirResolvePhase = FirResolvePhase.DECLARATIONS
+    ) where D : FirDeclaration, D : FirSymbolOwner<D>
 }

-internal val FirSession.phasedFirFileResolver: PhasedFirFileResolver? by FirSession.nullableSessionComponentAccessor()
+internal val FirSession.phaseManager: FirPhaseManager? by FirSession.nullableSessionComponentAccessor()
@@ -8,29 +8,17 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol

 fun <D> AbstractFirBasedSymbol<D>.phasedFir(
    requiredPhase: FirResolvePhase = FirResolvePhase.DECLARATIONS
 ): D where D : FirDeclaration, D : FirSymbolOwner<D> {
    val result = this.fir
-    val availablePhase = result.resolvePhase
-    if (availablePhase < requiredPhase) {
-        // NB: we should use session from symbol here, not transformer session (important for IDE)
-        val provider = fir.session.firProvider
+    val resolver = fir.session.phaseManager
+        ?: error("phasedFirFileResolver should be defined when working with FIR in phased mode")

-        require(provider.isPhasedFirAllowed) {
-            "Incorrect resolvePhase: actual: $availablePhase, expected: $requiredPhase\n For: ${fir.render()}"
-        }
+    resolver.ensureResolved(this, requiredPhase)

-        val resolver = fir.session.phasedFirFileResolver
-            ?: error("phasedFirFileResolver should be defined when working with FIR in phased mode")
-        resolver.resolveDeclaration(fir, fromPhase = availablePhase, toPhase = requiredPhase)
-    }
    return result
 }

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.fir.low.level.api
+
+import org.jetbrains.kotlin.fir.FirSymbolOwner
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.resolve.firProvider
+import org.jetbrains.kotlin.fir.resolve.transformers.FirPhaseManager
+import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.ModuleFileCache
+import org.jetbrains.kotlin.idea.fir.low.level.api.lazy.resolve.FirLazyDeclarationResolver
+
+internal class IdeFirPhaseManager(
+    private val lazyDeclarationResolver: FirLazyDeclarationResolver,
+    private val cache: ModuleFileCache
+) : FirPhaseManager() {
+    override fun <D> ensureResolved(
+        symbol: AbstractFirBasedSymbol<D>,
+        requiredPhase: FirResolvePhase
+    ) where D : FirDeclaration, D : FirSymbolOwner<D> {
+        val result = symbol.fir
+        val availablePhase = result.resolvePhase
+        if (availablePhase >= requiredPhase) return
+        // NB: we should use session from symbol here, not transformer session (important for IDE)
+        val provider = symbol.fir.session.firProvider
+
+        require(provider.isPhasedFirAllowed) {
+            "Incorrect resolvePhase: actual: $availablePhase, expected: $requiredPhase\n For: ${symbol.fir.render()}"
+        }
+
+        lazyDeclarationResolver.lazyResolveDeclaration(result, cache, requiredPhase, checkPCE = false)
+    }
+}
@@ -1,21 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.idea.fir.low.level.api
-
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.resolve.transformers.PhasedFirFileResolver
-import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.ModuleFileCache
-import org.jetbrains.kotlin.idea.fir.low.level.api.lazy.resolve.FirLazyDeclarationResolver
-
-internal class IdePhasedFirFileResolver(
-    private val lazyDeclarationResolver: FirLazyDeclarationResolver,
-    private val cache: ModuleFileCache
-) : PhasedFirFileResolver() {
-    override fun resolveDeclaration(declaration: FirDeclaration, fromPhase: FirResolvePhase, toPhase: FirResolvePhase) {
-        lazyDeclarationResolver.lazyResolveDeclaration(declaration, cache, toPhase, checkPCE = false)
-    }
-}
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
-import org.jetbrains.kotlin.fir.resolve.transformers.PhasedFirFileResolver
+import org.jetbrains.kotlin.fir.resolve.transformers.FirPhaseManager
 import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.fir.session.registerCommonComponents
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.fir.session.registerResolveComponents
 import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.caches.resolve.IDEPackagePartProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.IdePhasedFirFileResolver
+import org.jetbrains.kotlin.idea.fir.low.level.api.IdeFirPhaseManager
 import org.jetbrains.kotlin.idea.fir.low.level.api.IdeSessionComponents
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.ModuleFileCacheImpl
@@ -57,7 +57,7 @@ internal object FirIdeSessionFactory {
        val searchScope = ModuleWithDependentsScope(project, dependentModules.map { it.module })
        return FirIdeSourcesSession(moduleInfo, sessionProvider, searchScope, firBuilder).apply {
            val cache = ModuleFileCacheImpl(this)
-            val phasedFirFileResolver = IdePhasedFirFileResolver(FirLazyDeclarationResolver(firFileBuilder), cache)
+            val firPhaseManager = IdeFirPhaseManager(FirLazyDeclarationResolver(firFileBuilder), cache)

            registerCommonComponents()
            registerResolveComponents()
@@ -75,7 +75,7 @@ internal object FirIdeSessionFactory {
            register(FirProvider::class, provider)
            register(FirIdeProvider::class, provider)

-            register(PhasedFirFileResolver::class, phasedFirFileResolver)
+            register(FirPhaseManager::class, firPhaseManager)

            register(
                FirSymbolProvider::class,