Remove extra test methods (light tree)

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

@@ -22,9 +22,9 @@ import java.io.File
 import java.nio.file.Path
 
 class LightTree2Fir(
-    private val project: Project,
+    private val session: FirSession = object : FirSessionBase(null) {},
     private val stubMode: Boolean,
-    private val session: FirSession = object : FirSessionBase(null) {}
+    private val project: Project
 ) {
     //private val ktDummyFile = KtFile(SingleRootFileViewProvider(PsiManager.getInstance(project), LightVirtualFile()), false)
 

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt

@@ -703,7 +703,7 @@ class ExpressionsConverter(
         }
 
         //TODO psi must be null
-        return FirBlockImpl(session, KtForExpression(PsiForStatementImpl())).apply {
+        return FirBlockImpl(session, null).apply {
             val rangeVal =
                 generateTemporaryVariable(this@ExpressionsConverter.session, null, Name.special("<range>"), rangeExpression)
             statements += rangeVal

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.lightTree
 import com.intellij.testFramework.TestDataPath
 import junit.framework.TestCase
 import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.FirSessionBase
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.test.JUnit3RunnerWithInners
@@ -21,7 +20,7 @@ class LightTree2FirConverterTestCases : AbstractRawFirBuilderTestCase() {
     private val testDirPath = "compiler/fir/psi2fir/testData/rawBuilder/declarations"
 
     private fun executeTest(filePath: String) {
-        val lightTree2Fir = LightTree2Fir(myProject, stubMode = true).buildFirFile(Paths.get(filePath)).render()
+        val lightTree2Fir = LightTree2Fir(stubMode = true, project = myProject).buildFirFile(Paths.get(filePath)).render()
 
         val file = createKtFile(filePath)
         val firFile = file.toFirFile(stubMode = true)

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

@@ -11,7 +11,6 @@ import com.intellij.psi.impl.DebugUtil
 import com.intellij.testFramework.TestDataPath
 import com.intellij.util.PathUtil
 import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.FirSessionBase
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.JUnit3RunnerWithInners
@@ -47,7 +46,7 @@ class TotalKotlinTest : AbstractRawFirBuilderTestCase() {
         var counter = 0
         var time = 0L
 
-        val lightTreeConverter = LightTree2Fir(myProject, stubMode = true)
+        val lightTreeConverter = LightTree2Fir(stubMode = true, project = myProject)
 
         if (onlyLightTree) println("LightTree generation") else println("Fir from LightTree converter")
         println("BASE PATH: $path")

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/benchmark/generators/LightTree2FirGenerator.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.lightTree.benchmark.generators
 
 import com.intellij.psi.impl.DebugUtil
 import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.FirSessionBase
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.openjdk.jmh.annotations.Scope
@@ -17,13 +16,13 @@ import java.io.File
 @State(Scope.Benchmark)
 open class LightTree2FirGenerator : TreeGenerator, AbstractRawFirBuilderTestCase() {
     override fun generateBaseTree(text: String, file: File) {
-        val lightTreeConverter = LightTree2Fir(myProject, stubMode = false)
+        val lightTreeConverter = LightTree2Fir(stubMode = false, project = myProject)
         val lightTree = lightTreeConverter.buildLightTree(text)
         DebugUtil.lightTreeToString(lightTree, false)
     }
 
     override fun generateFir(text: String, file: File, stubMode: Boolean) {
-        val lightTreeConverter = LightTree2Fir(myProject, stubMode)
+        val lightTreeConverter = LightTree2Fir(stubMode = stubMode, project = myProject)
         val firFile = lightTreeConverter.buildFirFile(text, file.name)
         StringBuilder().also { FirRenderer(it).visitFile(firFile) }.toString()
     }

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/compare/DummyElement.kt

@@ -1,74 +0,0 @@
-/*
- * Copyright 2010-2019 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.fir.lightTree.compare
-
-import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSessionBase
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFunction
-import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.declarations.impl.FirVariableImpl
-import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList
-import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
-import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
-import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
-import org.jetbrains.kotlin.fir.visitors.FirVisitor
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.name.SpecialNames
-
-interface DummyElement
-
-class DummyFirStatement(
-    psi: PsiElement? = null,
-    session: FirSession = object : FirSessionBase(null) {}
-) : FirUnknownTypeExpression(session, psi), DummyElement
-
-class DummyFirVariable<F: FirVariable<F>>(
-    override val psi: PsiElement? = null,
-    override val session: FirSession = object : FirSessionBase(null) {},
-    override val annotations: List<FirAnnotationCall> = mutableListOf(),
-    override val receiverTypeRef: FirTypeRef? = null,
-    override val name: Name = SpecialNames.NO_NAME_PROVIDED,
-    override var returnTypeRef: FirTypeRef = FirImplicitTypeRefImpl(session, psi),
-    override val isVar: Boolean = false,
-    override var initializer: FirExpression? = null,
-    override val symbol: FirVariableSymbol<F> = FirVariableSymbol(name),
-    override var delegate: FirExpression? = null
-) : FirVariable<F>, DummyElement {
-    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D) {
-        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
-    }
-}
-
-class DummyFirAnonymousFunction(
-    psi: PsiElement? = null,
-    session: FirSession = object : FirSessionBase(null) {},
-    override val valueParameters: List<FirValueParameter> = listOf(),
-    override val body: FirBlock? = null,
-    override val receiverTypeRef: FirTypeRef? = null,
-    override var returnTypeRef: FirTypeRef = FirImplicitTypeRefImpl(session, psi)
-) : FirAnonymousFunction(session, psi),
-    DummyElement {
-    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D) {
-        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
-    }
-}
-
-class DummyFirDeclaration(
-    override val psi: PsiElement? = null,
-    override val session: FirSession = object : FirSessionBase(null) {},
-    override val annotations: List<FirAnnotationCall> = listOf()
-) : FirDeclaration, FirStatement, DummyElement {
-    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitDeclaration(this, data)
-}

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/compare/FirComparator.kt

@@ -1,36 +0,0 @@
-/*
- * Copyright 2010-2019 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.fir.lightTree.compare
-
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
-
-class FirVisitorForComparator : FirVisitorVoid() {
-    val firTreeNodesClasses: MutableList<String> = mutableListOf()
-
-    override fun visitElement(element: FirElement) {
-        if (element !is DummyElement) {
-            firTreeNodesClasses += element.javaClass.canonicalName
-            element.acceptChildren(this)
-        }
-    }
-}
-
-fun FirFile.areEqualTo(firFile: FirFile): Boolean {
-    val thisFirList = FirVisitorForComparator().apply { visitFile(this@areEqualTo) }.firTreeNodesClasses
-    val otherFirList = FirVisitorForComparator().apply { visitFile(firFile) }.firTreeNodesClasses
-
-    if (thisFirList.size != otherFirList.size) return false
-
-    for (i in 0 until thisFirList.size) {
-        if (thisFirList[i] != otherFirList[i]) {
-            return false
-        }
-    }
-
-    return true
-}

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/compare/FirPartialTransformer.kt

@@ -1,263 +0,0 @@
-/*
- * Copyright 2010-2019 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.fir.lightTree.compare
-
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractCallableMember
-import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.*
-import org.jetbrains.kotlin.fir.resolve.transformers.FirAbstractTreeTransformer
-import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
-import org.jetbrains.kotlin.fir.visitors.compose
-import org.jetbrains.kotlin.psi.KtForExpression
-import org.jetbrains.kotlin.psi.KtLambdaExpression
-
-class FirPartialTransformer(
-    private val visitAnonymousFunction: Boolean = false,
-    private val visitLambdaExpression: Boolean = false,
-    private val visitLocalMembers: Boolean = false,
-    private val visitVariable: Boolean = false,
-    private val visitAnnotation: Boolean = false,
-    private val visitTypeOperatorCall: Boolean = false,
-    private val visitArrayOfCall: Boolean = false,
-    private val visitFunctionCall: Boolean = false,
-    private val visitGetClassCall: Boolean = false,
-    private val visitLoopJump: Boolean = false,
-    private val visitReturnExpression: Boolean = false,
-    private val visitThrowExpression: Boolean = false,
-    private val visitLoops: Boolean = false,
-    private val visitConstExpression: Boolean = false,
-    private val visitQualifiedAccessExpression: Boolean = false,
-    private val visitCallableReferenceAccess: Boolean = false,
-    private val visitTryExpression: Boolean = false,
-    private val visitWhenExpression: Boolean = false,
-    private val visitLambdaArgumentExpression: Boolean = false,
-    private val visitAnonymousObject: Boolean = false
-) : FirAbstractTreeTransformer() {
-    override fun transformAnonymousFunction(
-        anonymousFunction: FirAnonymousFunction,
-        data: Nothing?
-    ): CompositeTransformResult<FirDeclaration> {
-        return if (visitAnonymousFunction) {
-            (anonymousFunction.transformChildren(this, data) as FirAnonymousFunction).compose()
-        } else if (visitLambdaExpression && anonymousFunction.psi is KtLambdaExpression) {
-            (anonymousFunction.transformChildren(this, data) as FirAnonymousFunction).compose()
-        } else {
-            DummyFirAnonymousFunction().compose()
-        }
-    }
-
-    override fun transformNamedFunction(namedFunction: FirNamedFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> {
-        return if (!visitLocalMembers && namedFunction is FirAbstractCallableMember<*> && namedFunction.visibility == Visibilities.LOCAL) {
-            DummyFirDeclaration().compose()
-        } else {
-            (namedFunction.transformChildren(this, data) as FirNamedFunction).compose()
-        }
-    }
-
-    override fun transformMemberDeclaration(
-        memberDeclaration: FirMemberDeclaration,
-        data: Nothing?
-    ): CompositeTransformResult<FirDeclaration> {
-        return if (!visitLocalMembers && memberDeclaration.visibility == Visibilities.LOCAL) {
-            DummyFirDeclaration().compose()
-        } else {
-            (memberDeclaration.transformChildren(this, data) as FirMemberDeclaration).compose()
-        }
-    }
-
-    override fun <F : FirVariable<F>> transformVariable(variable: FirVariable<F>, data: Nothing?): CompositeTransformResult<FirDeclaration> {
-        return if (visitVariable) {
-            (variable.transformChildren(this, data) as FirVariable<*>).compose()
-        } else {
-            DummyFirVariable<F>().compose()
-        }
-    }
-
-    override fun transformExpression(expression: FirExpression, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (expression is FirExpressionStub) {
-            DummyFirStatement().compose()
-        } else {
-            super.transformExpression(expression, data)
-        }
-    }
-
-    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?): CompositeTransformResult<FirAnnotationCall> {
-        return if (visitAnnotation) {
-            (annotationCall.transformChildren(this, data) as FirAnnotationCall).compose()
-        } else {
-            CompositeTransformResult.empty()
-        }
-    }
-
-    override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitTypeOperatorCall) {
-            (typeOperatorCall.transformChildren(this, data) as FirTypeOperatorCall).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitArrayOfCall) {
-            (arrayOfCall.transformChildren(this, data) as FirArrayOfCall).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformFunctionCall(functionCall: FirFunctionCall, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitFunctionCall) {
-            (functionCall.transformChildren(this, data) as FirFunctionCall).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformGetClassCall(getClassCall: FirGetClassCall, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitGetClassCall) {
-            (getClassCall.transformChildren(this, data) as FirGetClassCall).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformBreakExpression(breakExpression: FirBreakExpression, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitLoopJump) {
-            (breakExpression.transformChildren(this, data) as FirBreakExpression).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformContinueExpression(
-        continueExpression: FirContinueExpression,
-        data: Nothing?
-    ): CompositeTransformResult<FirStatement> {
-        return if (visitLoopJump) {
-            (continueExpression.transformChildren(this, data) as FirContinueExpression).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformReturnExpression(returnExpression: FirReturnExpression, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitReturnExpression) {
-            (returnExpression.transformChildren(this, data) as FirReturnExpression).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformThrowExpression(throwExpression: FirThrowExpression, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitThrowExpression) {
-            (throwExpression.transformChildren(this, data) as FirThrowExpression).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformBlock(block: FirBlock, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (!visitLoops && block.psi is KtForExpression) {
-            DummyFirStatement().compose()
-        } else {
-            super.transformBlock(block, data)
-        }
-    }
-
-    override fun <T> transformConstExpression(
-        constExpression: FirConstExpression<T>,
-        data: Nothing?
-    ): CompositeTransformResult<FirStatement> {
-        return if (visitConstExpression) {
-            (constExpression.transformChildren(this, data) as FirConstExpression<*>).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformQualifiedAccessExpression(
-        qualifiedAccessExpression: FirQualifiedAccessExpression,
-        data: Nothing?
-    ): CompositeTransformResult<FirStatement> {
-        return if (visitQualifiedAccessExpression) {
-            (qualifiedAccessExpression.transformChildren(this, data) as FirQualifiedAccessExpression).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformCallableReferenceAccess(
-        callableReferenceAccess: FirCallableReferenceAccess,
-        data: Nothing?
-    ): CompositeTransformResult<FirStatement> {
-        return if (visitCallableReferenceAccess) {
-            (callableReferenceAccess.transformChildren(this, data) as FirCallableReferenceAccess).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformTryExpression(tryExpression: FirTryExpression, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitTryExpression) {
-            (tryExpression.transformChildren(this, data) as FirTryExpression).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitWhenExpression) {
-            (whenExpression.transformChildren(this, data) as FirWhenExpression).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformLambdaArgumentExpression(
-        lambdaArgumentExpression: FirLambdaArgumentExpression,
-        data: Nothing?
-    ): CompositeTransformResult<FirStatement> {
-        return if (visitLambdaArgumentExpression) {
-            (lambdaArgumentExpression.transformChildren(this, data) as FirLambdaArgumentExpression).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitAnonymousObject) {
-            (anonymousObject.transformChildren(this, data) as FirAnonymousObject).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitLoops) {
-            (doWhileLoop.transformChildren(this, data) as FirDoWhileLoop).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformWhileLoop(whileLoop: FirWhileLoop, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitLoops) {
-            (whileLoop.transformChildren(this, data) as FirWhileLoop).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-
-    override fun transformAssignment(assignment: FirAssignment, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return if (visitVariable) {
-            (assignment.transformChildren(this, data) as FirAssignment).compose()
-        } else {
-            DummyFirStatement().compose()
-        }
-    }
-}

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/compare/TreesCompareTest.kt

@@ -11,7 +11,6 @@ import com.intellij.testFramework.TestDataPath
 import com.intellij.util.PathUtil
 import junit.framework.TestCase
 import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.FirSessionBase
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.jetbrains.kotlin.fir.lightTree.walkTopDown
@@ -44,7 +43,7 @@ class TreesCompareTest : AbstractRawFirBuilderTestCase() {
     }
 
     private fun compareAll(stubMode: Boolean) {
-        val lightTreeConverter = LightTree2Fir(myProject, stubMode)
+        val lightTreeConverter = LightTree2Fir(stubMode = stubMode, project = myProject)
         compareBase(System.getProperty("user.dir"), withTestData = false) { file ->
             val text = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim()
 
@@ -62,7 +61,7 @@ class TreesCompareTest : AbstractRawFirBuilderTestCase() {
     }
 
     fun testCompareDiagnostics() {
-        val lightTreeConverter = LightTree2Fir(myProject, stubMode = false)
+        val lightTreeConverter = LightTree2Fir(stubMode = false, project = myProject)
         compareBase("compiler/testData/diagnostics/tests", withTestData = true) { file ->
             val notEditedText = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim()
             val text = notEditedText.replace("(<!>)|(<!.*?!>)".toRegex(), "").replaceAfter(".java", "")
@@ -82,72 +81,6 @@ class TreesCompareTest : AbstractRawFirBuilderTestCase() {
         }
     }
 
-    private fun compare(
-        stubMode: Boolean,
-        path: String = System.getProperty("user.dir"),
-        withTestData: Boolean = false,
-        visitAnonymousFunction: Boolean = false,
-        visitLambdaExpression: Boolean = false,
-        visitLocalMembers: Boolean = false,
-        visitVariable: Boolean = false,
-        visitAnnotation: Boolean = false,
-        visitTypeOperatorCall: Boolean = false,
-        visitArrayOfCall: Boolean = false,
-        visitFunctionCall: Boolean = false,
-        visitGetClassCall: Boolean = false,
-        visitLoopJump: Boolean = false,
-        visitReturnExpression: Boolean = false,
-        visitThrowExpression: Boolean = false,
-        visitLoops: Boolean = false,
-        visitConstExpression: Boolean = false,
-        visitQualifiedAccessExpression: Boolean = false,
-        visitCallableReferenceAccess: Boolean = false,
-        visitTryExpression: Boolean = false,
-        visitWhenExpression: Boolean = false,
-        visitLambdaArgumentExpression: Boolean = false,
-        visitAnonymousObject: Boolean = false
-    ) {
-        val firVisitor = FirPartialTransformer(
-            visitAnonymousFunction = visitAnonymousFunction,
-            visitLambdaExpression = visitLambdaExpression,
-            visitLocalMembers = visitLocalMembers,
-            visitVariable = visitVariable,
-            visitAnnotation = visitAnnotation,
-            visitTypeOperatorCall = visitTypeOperatorCall,
-            visitArrayOfCall = visitArrayOfCall,
-            visitFunctionCall = visitFunctionCall,
-            visitGetClassCall = visitGetClassCall,
-            visitLoopJump = visitLoopJump,
-            visitReturnExpression = visitReturnExpression,
-            visitThrowExpression = visitThrowExpression,
-            visitLoops = visitLoops,
-            visitConstExpression = visitConstExpression,
-            visitQualifiedAccessExpression = visitQualifiedAccessExpression,
-            visitCallableReferenceAccess = visitCallableReferenceAccess,
-            visitTryExpression = visitTryExpression,
-            visitWhenExpression = visitWhenExpression,
-            visitLambdaArgumentExpression = visitLambdaArgumentExpression,
-            visitAnonymousObject = visitAnonymousObject
-        )
-        val lightTreeConverter = LightTree2Fir(myProject, stubMode)
-        compareBase(path, withTestData) { file ->
-            val text = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim()
-
-            //light tree
-            val firFileFromLightTree = lightTreeConverter.buildFirFile(text, file.name)
-            firVisitor.transformFile(firFileFromLightTree, null)
-            //val treeFromLightTree = StringBuilder().also { FirRenderer(it).visitFile(firVisitor.transformFile(firFileFromLightTree, null).single) }.toString()
-
-            //psi
-            val ktFile = createPsiFile(FileUtil.getNameWithoutExtension(PathUtil.getFileName(file.path)), text) as KtFile
-            val firFileFromPsi = ktFile.toFirFile(stubMode)
-            firVisitor.transformFile(firFileFromPsi, null)
-            //val treeFromPsi = StringBuilder().also { FirRenderer(it).visitFile(firVisitor.transformFile(firFileFromPsi, null).single) }.toString()
-
-            return@compareBase firFileFromPsi.areEqualTo(firFileFromLightTree)
-        }
-    }
-
     fun testStubCompareAll() {
         compareAll(stubMode = true)
     }
@@ -155,235 +88,4 @@ class TreesCompareTest : AbstractRawFirBuilderTestCase() {
     fun testCompareAll() {
         compareAll(stubMode = false)
     }
-
-    fun testStubCompareWithoutAnnotations() {
-        compare(stubMode = true, visitAnnotation = false)
-    }
-
-    fun testConstExpression() {
-        compare(stubMode = false, visitConstExpression = true, visitAnnotation = true)
-    }
-
-    fun testCallExpression() {
-        compare(stubMode = false, visitFunctionCall = true, visitLambdaExpression = false)
-    }
-
-    fun testQualifiedAccessExpression() {
-        compare(stubMode = false, visitFunctionCall = true, visitQualifiedAccessExpression = true)
-    }
-
-    fun testTypeOperatorCall() {
-        compare(
-            stubMode = false,
-            visitTypeOperatorCall = true,
-            visitFunctionCall = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true
-        )
-    }
-
-    fun testArrayOfCall() {
-        compare(
-            stubMode = false,
-            visitTypeOperatorCall = true,
-            visitArrayOfCall = true,
-            visitFunctionCall = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true
-        )
-    }
-
-    fun testDoubleColonSuffix() {
-        compare(
-            stubMode = false,
-            visitTypeOperatorCall = true,
-            visitArrayOfCall = true,
-            visitFunctionCall = true,
-            visitGetClassCall = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true,
-            visitCallableReferenceAccess = true
-        )
-    }
-
-    fun testLocalMembers() {
-        compare(
-            stubMode = false,
-            visitLocalMembers = true,
-            visitAnnotation = true,
-            visitTypeOperatorCall = true,
-            visitArrayOfCall = true,
-            visitFunctionCall = true,
-            visitGetClassCall = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true,
-            visitCallableReferenceAccess = true
-        )
-    }
-
-    fun testReturn() {
-        compare(
-            stubMode = false,
-            visitLocalMembers = true,
-            visitAnnotation = true,
-            visitTypeOperatorCall = true,
-            visitArrayOfCall = true,
-            visitFunctionCall = true,
-            visitGetClassCall = true,
-            visitReturnExpression = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true,
-            visitCallableReferenceAccess = true
-        )
-    }
-
-    fun testLambdaExpression() {
-        compare(
-            stubMode = false,
-            visitAnonymousFunction = true,
-            visitLambdaExpression = true,
-            visitLocalMembers = true,
-            visitAnnotation = true,
-            visitTypeOperatorCall = true,
-            visitArrayOfCall = true,
-            visitFunctionCall = true,
-            visitGetClassCall = true,
-            visitReturnExpression = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true,
-            visitCallableReferenceAccess = true
-        )
-    }
-
-    fun testLambdaArgument() {
-        compare(
-            stubMode = false,
-            visitAnonymousFunction = true,
-            visitLambdaExpression = true,
-            visitLocalMembers = true,
-            visitAnnotation = true,
-            visitTypeOperatorCall = true,
-            visitArrayOfCall = true,
-            visitFunctionCall = true,
-            visitGetClassCall = true,
-            visitReturnExpression = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true,
-            visitCallableReferenceAccess = true,
-            visitLambdaArgumentExpression = true
-        )
-    }
-
-    fun testAnonymousObject() {
-        compare(
-            stubMode = false,
-            visitAnonymousFunction = true,
-            visitLambdaExpression = true,
-            visitLocalMembers = true,
-            visitAnnotation = true,
-            visitTypeOperatorCall = true,
-            visitArrayOfCall = true,
-            visitFunctionCall = true,
-            visitGetClassCall = true,
-            visitReturnExpression = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true,
-            visitCallableReferenceAccess = true,
-            visitLambdaArgumentExpression = true,
-            visitAnonymousObject = true
-        )
-    }
-
-    fun testLoops() {
-        compare(
-            stubMode = false,
-            visitLambdaExpression = true,
-            visitAnnotation = true,
-            visitFunctionCall = true,
-            visitReturnExpression = true,
-            visitLoops = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true
-        )
-    }
-
-    fun testVariables() {
-        compare(
-            stubMode = false,
-            visitAnonymousFunction = true,
-            visitLambdaExpression = true,
-            visitLocalMembers = true,
-            visitVariable = true,
-            visitAnnotation = true,
-            visitFunctionCall = true,
-            visitLoops = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true,
-            visitAnonymousObject = true
-        )
-    }
-
-    fun testLoopJump() {
-        compare(
-            stubMode = false,
-            visitAnnotation = true,
-            visitLoopJump = true,
-            visitLoops = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true
-        )
-    }
-
-    fun testThrowExpression() {
-        compare(
-            stubMode = false,
-            visitAnonymousFunction = true,
-            visitLambdaExpression = true,
-            visitLocalMembers = true,
-            visitVariable = true,
-            visitAnnotation = true,
-            visitFunctionCall = true,
-            visitThrowExpression = true,
-            visitLoops = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true,
-            visitAnonymousObject = true
-        )
-    }
-
-    fun testTryExpression() {
-        compare(
-            stubMode = false,
-            visitAnonymousFunction = true,
-            visitLambdaExpression = true,
-            visitLocalMembers = true,
-            visitVariable = true,
-            visitAnnotation = true,
-            visitFunctionCall = true,
-            visitThrowExpression = true,
-            visitLoops = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true,
-            visitTryExpression = true,
-            visitAnonymousObject = true
-        )
-    }
-
-    fun testWhenExpression() {
-        compare(
-            stubMode = false,
-            visitAnonymousFunction = true,
-            visitLambdaExpression = true,
-            visitLocalMembers = true,
-            visitVariable = true,
-            visitAnnotation = true,
-            visitFunctionCall = true,
-            visitThrowExpression = true,
-            visitLoops = true,
-            visitConstExpression = true,
-            visitQualifiedAccessExpression = true,
-            visitWhenExpression = true,
-            visitAnonymousObject = true
-        )
-    }
 }