[FIR] Introduce FirResolveProcessors

2020-05-20 12:30:12 +03:00
parent 96802dde04
commit 8d686226c7
24 changed files with 260 additions and 125 deletions
@@ -48,10 +48,9 @@ import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.createSession
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc
-import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.AnalyzingUtils
@@ -128,14 +127,14 @@ object GenerationUtils {

        val firProvider = (session.firProvider as FirProviderImpl)
        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
-        val resolveTransformer = FirTotalResolveTransformer(session)
+        val resolveTransformer = FirTotalResolveProcessor(session)
        val firFiles = files.map {
            val firFile = builder.buildFirFile(it)
            firProvider.recordFile(firFile)
            firFile
        }.also {
            try {
-                resolveTransformer.processFiles(it)
+                resolveTransformer.process(it)
            } catch (e: Exception) {
                throw e
            }
@@ -28,7 +28,8 @@ import org.jetbrains.kotlin.fir.resolve.dfa.cfg.CFGNode
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.ControlFlowGraph
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.EdgeKind
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.FirControlFlowGraphRenderVisitor
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.createAllResolveProcessors
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -76,7 +77,7 @@ abstract class AbstractFirDiagnosticsTest : AbstractFirBaseDiagnosticsTest() {
        for ((session, firFiles) in firFilesPerSession) {
            doFirResolveTestBench(
                firFiles,
-                FirTotalResolveTransformer(session).transformers,
+                createAllResolveProcessors(session),
                gc = false
            )
        }
@@ -6,7 +6,8 @@
 package org.jetbrains.kotlin.fir

 import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.createAllResolveProcessors
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import java.io.File

@@ -32,7 +33,7 @@ abstract class AbstractFirOldFrontendDiagnosticsTest : AbstractFirDiagnosticsTes
    override fun runAnalysis(testDataFile: File, testFiles: List<TestFile>, firFilesPerSession: Map<FirSession, List<FirFile>>) {
        val failure: FirRuntimeException? = try {
            for ((session, firFiles) in firFilesPerSession) {
-                doFirResolveTestBench(firFiles, FirTotalResolveTransformer(session).transformers, gc = false)
+                doFirResolveTestBench(firFiles, createAllResolveProcessors(session), gc = false)
            }
            null
        } catch (e: FirRuntimeException) {
@@ -18,9 +18,11 @@ import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
+import org.jetbrains.kotlin.fir.resolve.transformers.FirResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.FirGlobalResolveProcessor
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.utils.addToStdlib.sumByLong
@@ -154,47 +156,75 @@ class FirResolveBench(val withProgress: Boolean) {
        }
    }

-    private fun runStage(transformer: FirTransformer<Nothing?>, firFileSequence: Sequence<FirFile>) {
+    private fun runStage(processor: FirResolveProcessor, firFileSequence: Sequence<FirFile>) {
+        when (processor) {
+            is FirTransformerBasedResolveProcessor -> runStage(processor, firFileSequence)
+            is FirGlobalResolveProcessor -> runStage(processor)
+        }
+    }
+
+    private fun runStage(processor: FirTransformerBasedResolveProcessor, firFileSequence: Sequence<FirFile>) {
+        val transformer = processor.transformer
        for (firFile in firFileSequence) {
-            var fail = false
-            val before = vmStateSnapshot()
-            val time = measureNanoTime {
-                try {
-                    transformer.transformFile(firFile, null)
-                } catch (e: Throwable) {
-                    val ktFile = firFile.psi
-                    if (ktFile is KtFile) {
-                        println("Fail in file: ${ktFile.virtualFilePath}")
-                        fails += FailureInfo(transformer::class, e, ktFile.virtualFilePath)
-                    } else {
-                        println("Fail in file: ${firFile.packageFqName} / ${firFile.name}")
-                        fails += FailureInfo(transformer::class, e, firFile.packageFqName.asString() + "/" + firFile.name)
-                    }
-                    fail = true
-                    //println(ktFile.text)
-                    //throw e
+            processWithTimeMeasure(
+                transformer::class,
+                { transformer.transformFile(firFile, null) }
+            ) { e ->
+                val ktFile = firFile.psi
+                if (ktFile is KtFile) {
+                    println("Fail in file: ${ktFile.virtualFilePath}")
+                    FailureInfo(transformer::class, e, ktFile.virtualFilePath)
+                } else {
+                    println("Fail in file: ${firFile.packageFqName} / ${firFile.name}")
+                    FailureInfo(transformer::class, e, firFile.packageFqName.asString() + "/" + firFile.name)
                }
            }
-            if (!fail) {
-                val after = vmStateSnapshot()
-                val diff = after - before
-                recordTime(transformer::class, diff, time)
+        }
+    }

+    private fun runStage(processor: FirGlobalResolveProcessor) {
+        processWithTimeMeasure(
+            processor::class,
+            { processor.process() }
+        ) { e ->
+            val message = "Fail on stage ${processor::class}"
+            println(message)
+            FailureInfo(processor::class, e, message)
+        }
+    }
+
+    private inline fun processWithTimeMeasure(
+        kClass: KClass<*>,
+        block: () -> Unit,
+        catchBlock: (Throwable) -> FailureInfo
+    ) {
+        var fail = false
+        val before = vmStateSnapshot()
+        val time = measureNanoTime {
+            try {
+                block()
+            } catch (e: Throwable) {
+                fails += catchBlock(e)
+                fail = true
            }
-            //totalLength += StringBuilder().apply { FirRenderer(this).visitFile(firFile) }.length
+        }
+        if (!fail) {
+            val after = vmStateSnapshot()
+            val diff = after - before
+            recordTime(kClass, diff, time)
        }
    }

    fun processFiles(
        firFiles: List<FirFile>,
-        transformers: List<FirTransformer<Nothing?>>
+        processors: List<FirResolveProcessor>
    ) {
        fileCount += firFiles.size
        try {
-            for ((stage, transformer) in transformers.withIndex()) {
+            for ((stage, processor) in processors.withIndex()) {
                //println("Starting stage #$stage. $transformer")
                val firFileSequence = if (withProgress) firFiles.progress("   ~ ") else firFiles.asSequence()
-                runStage(transformer, firFileSequence)
+                runStage(processor, firFileSequence)
                checkFirProvidersConsistency(firFiles)
            }

@@ -205,7 +235,6 @@ class FirResolveBench(val withProgress: Boolean) {
            }
        } finally {

-
            val fileDocumentManager = FileDocumentManager.getInstance()

            firFiles.forEach {
@@ -327,7 +356,7 @@ class FirResolveBench(val withProgress: Boolean) {

 fun doFirResolveTestBench(
    firFiles: List<FirFile>,
-    transformers: List<FirTransformer<Nothing?>>,
+    processors: List<FirResolveProcessor>,
    gc: Boolean = true,
    withProgress: Boolean = false,
    silent: Boolean = true
@@ -338,7 +367,7 @@ fun doFirResolveTestBench(
    }

    val bench = FirResolveBench(withProgress)
-    bench.processFiles(firFiles, transformers)
+    bench.processFiles(firFiles, processors)
    if (!silent) bench.getTotalStatistics().report(System.out, "")
    bench.throwFailure()
 }