Add separated tests for tree generation and fir convertion

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/LightTree2Fir.kt

@@ -5,31 +5,38 @@
 
 package org.jetbrains.kotlin.fir.lightTree
 
+import com.intellij.lang.LighterASTNode
 import com.intellij.lang.ParserDefinition
 import com.intellij.lang.impl.PsiBuilderFactoryImpl
 import com.intellij.lexer.Lexer
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.vfs.CharsetToolkit
+import com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.fir.FirSessionBase
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.parsing.MyKotlinParser
 import java.io.File
 import java.nio.file.Path
 
-class LightTree2Fir(val stubMode: Boolean, private val parserDefinition: ParserDefinition, private val lexer: Lexer) {
+class LightTree2Fir(private val stubMode: Boolean, private val parserDefinition: ParserDefinition, private val lexer: Lexer) {
     fun buildFirFile(path: Path): FirFile {
         return buildFirFile(path.toFile())
     }
 
     fun buildFirFile(file: File): FirFile {
-        val text = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim()
+        val code = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim()
-        return buildFirFile(text, file.name)
+        return buildFirFile(code, file.name)
     }
 
-    fun buildFirFile(text: String, fileName: String): FirFile {
+    fun buildLightTree(code: String): FlyweightCapableTreeStructure<LighterASTNode> {
-        val builder = PsiBuilderFactoryImpl().createBuilder(parserDefinition, lexer, text)
+        val builder = PsiBuilderFactoryImpl().createBuilder(parserDefinition, lexer, code)
         MyKotlinParser.parse(builder)
+        return builder.lightTree
+    }
 
-        return Converter(object : FirSessionBase() {}, stubMode, builder.lightTree).convertFile(builder.lightTree.root, fileName)
+    fun buildFirFile(code: String, fileName: String): FirFile {
+        val lightTree = buildLightTree(code)
+
+        return Converter(object : FirSessionBase() {}, stubMode, lightTree).convertFile(lightTree.root, fileName)
     }
 }

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/LightTree2FirConverterTotalKotlin.kt

@@ -28,7 +28,7 @@ import kotlin.system.measureNanoTime
 @TestDataPath("\$PROJECT_ROOT")
 @RunWith(JUnit3RunnerWithInners::class)
 class LightTree2FirConverterTotalKotlin : AbstractRawFirBuilderTestCase() {
-    fun testTotalKotlinLight() {
+    private fun totalKotlinLight(onlyLightTree: Boolean) {
         val path = System.getProperty("user.dir")
         val root = File(path)
         var counter = 0
@@ -38,7 +38,7 @@ class LightTree2FirConverterTotalKotlin : AbstractRawFirBuilderTestCase() {
         val lexer = parserDefinition.createLexer(myProject)
         val lightTreeConverter = LightTree2Fir(true, parserDefinition, lexer)
 
-        println("light test")
+        if (onlyLightTree) println("LightTree generation") else println("Fir from LightTree converter")
         println("BASE PATH: $path")
         for (file in root.walkTopDown()) {
             if (file.isDirectory) continue
@@ -47,8 +47,13 @@ class LightTree2FirConverterTotalKotlin : AbstractRawFirBuilderTestCase() {
 
             val text = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim()
             time += measureNanoTime {
-                val firFile = lightTreeConverter.buildFirFile(text, file.name)
+                if (onlyLightTree) {
-                StringBuilder().also { FirRenderer(it).visitFile(firFile) }.toString()
+                    val lightTree = lightTreeConverter.buildLightTree(text)
+                    DebugUtil.lightTreeToString(lightTree, false)
+                } else {
+                    val firFile = lightTreeConverter.buildFirFile(text, file.name)
+                    StringBuilder().also { FirRenderer(it).visitFile(firFile) }.toString()
+                }
             }
 
             counter++
@@ -58,13 +63,13 @@ class LightTree2FirConverterTotalKotlin : AbstractRawFirBuilderTestCase() {
 
     }
 
-    fun testTotalKotlinPsi() {
+    private fun totalKotlinPsi(onlyPsi: Boolean) {
         val path = System.getProperty("user.dir")
         val root = File(path)
         var counter = 0
         var time = 0L
 
-        println("psi test")
+        if (onlyPsi) println("Psi generation") else println("Fir from Psi converter")
         println("BASE PATH: $path")
         for (file in root.walkTopDown()) {
             if (file.isDirectory) continue
@@ -74,8 +79,12 @@ class LightTree2FirConverterTotalKotlin : AbstractRawFirBuilderTestCase() {
             val text = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim()
             time += measureNanoTime {
                 val ktFile = createPsiFile(FileUtil.getNameWithoutExtension(PathUtil.getFileName(file.path)), text) as KtFile
-                val firFile = ktFile.toFirFile(stubMode = true)
+                if (onlyPsi) {
-                StringBuilder().also { FirRenderer(it).visitFile(firFile) }.toString()
+                    DebugUtil.psiTreeToString(ktFile, false)
+                } else {
+                    val firFile = ktFile.toFirFile(stubMode = true)
+                    StringBuilder().also { FirRenderer(it).visitFile(firFile) }.toString()
+                }
             }
 
             counter++
@@ -84,4 +93,20 @@ class LightTree2FirConverterTotalKotlin : AbstractRawFirBuilderTestCase() {
         println("TIME PER FILE: ${(time / counter) * 1e-6} ms, COUNTER: $counter")
 
     }
+
+    fun testTotalKotlinOnlyLightTree() {
+        totalKotlinLight(true)
+    }
+
+    fun testTotalKotlinOnlyPsi() {
+        totalKotlinPsi(true)
+    }
+
+    fun testTotalKotlinFirFromLightTree() {
+        totalKotlinLight(false)
+    }
+
+    fun testTotalKotlinFirFromPsi() {
+        totalKotlinPsi(false)
+    }
 }