[RAW FIR] Rename raw FIR builder types for clarity

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/builder/LLFirFileBuilder.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveCompone
 import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
 import org.jetbrains.kotlin.analysis.utils.errors.checkWithAttachmentBuilder
 import org.jetbrains.kotlin.fir.builder.BodyBuildingMode
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.psi.KtFile
 
@@ -44,7 +44,7 @@ internal class LLFirFileBuilder(val moduleComponents: LLFirModuleResolveComponen
             else -> BodyBuildingMode.LAZY_BODIES
         }
 
-        RawFirBuilder(
+        PsiRawFirBuilder(
             moduleComponents.session,
             moduleComponents.scopeProvider,
             bodyBuildingMode = bodyBuildingMode

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt

@@ -10,7 +10,7 @@ import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.toPersistentList
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation
 import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.getExplicitBackingField
 import org.jetbrains.kotlin.fir.expressions.*
@@ -59,7 +59,7 @@ internal object FirLazyBodiesCalculator {
 
     fun calculateLazyArgumentsForAnnotation(annotationCall: FirAnnotationCall, session: FirSession): FirArgumentList {
         require(needCalculatingAnnotationCall(annotationCall))
-        val builder = RawFirBuilder(session, baseScopeProvider = session.kotlinScopeProvider)
+        val builder = PsiRawFirBuilder(session, baseScopeProvider = session.kotlinScopeProvider)
         val ktAnnotationEntry = annotationCall.psi as KtAnnotationEntry
         builder.context.packageFqName = ktAnnotationEntry.containingKtFile.packageFqName
         val newAnnotationCall = builder.buildAnnotationCall(ktAnnotationEntry)

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/RawFirFileAnnotationBuilder.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.psi.KtAnnotationEntry
@@ -22,7 +22,7 @@ internal fun buildFileFirAnnotation(
 
     val replacementApplier = replacement?.Applier()
 
-    val builder = object : RawFirBuilder(session, baseScopeProvider) {
+    val builder = object : PsiRawFirBuilder(session, baseScopeProvider) {
         inner class VisitorWithReplacement : Visitor() {
             override fun convertElement(element: KtElement, original: FirElement?): FirElement? =
                 super.convertElement(replacementApplier?.tryReplace(element) ?: element, original)

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/RawFirNonLocalDeclarationBuilder.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
 import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.builder.BodyBuildingMode
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.FirBackingFieldBuilder
 import org.jetbrains.kotlin.fir.declarations.builder.FirFunctionBuilder
@@ -45,7 +45,7 @@ internal class RawFirNonLocalDeclarationBuilder private constructor(
     private val additionalPropertyInit: FirPropertyBuilder.() -> Unit = {},
     private val additionalAccessorInit: FirPropertyAccessorBuilder.() -> Unit = {},
     private val additionalBackingFieldInit: FirBackingFieldBuilder.() -> Unit = {},
-) : RawFirBuilder(session, baseScopeProvider, bodyBuildingMode = BodyBuildingMode.NORMAL) {
+) : PsiRawFirBuilder(session, baseScopeProvider, bodyBuildingMode = BodyBuildingMode.NORMAL) {
     override fun FirFunctionBuilder.additionalFunctionInit() {
         additionalFunctionInit.invoke(this)
     }
@@ -68,7 +68,7 @@ internal class RawFirNonLocalDeclarationBuilder private constructor(
             scopeProvider: FirScopeProvider,
             file: KtFile,
         ): FirFile {
-            val builder = RawFirBuilder(session,scopeProvider, bodyBuildingMode = BodyBuildingMode.LAZY_BODIES)
+            val builder = PsiRawFirBuilder(session, scopeProvider, bodyBuildingMode = BodyBuildingMode.LAZY_BODIES)
             return builder.buildFirFile(file)
         }
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/RawFirUserTypeRefBuilder.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.types.FirUserTypeRef
 import org.jetbrains.kotlin.psi.KtTypeReference
@@ -16,7 +16,7 @@ internal fun buildFirUserTypeRef(
     session: FirSession,
     baseScopeProvider: FirScopeProvider
 ): FirUserTypeRef {
-    val builder = object : RawFirBuilder(session, baseScopeProvider) {
+    val builder = object : PsiRawFirBuilder(session, baseScopeProvider) {
         fun build(): FirUserTypeRef = Visitor().visitTypeReference(typeReference, null) as FirUserTypeRef
     }
     builder.context.packageFqName = typeReference.containingKtFile.packageFqName

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirLazyBodiesCalculatorTest.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.test.configurators.Analys
 import org.jetbrains.kotlin.analysis.low.level.api.fir.test.configurators.AnalysisApiFirSourceTestConfigurator
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.builder.BodyBuildingMode
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.expressions.FirLazyBlock
 import org.jetbrains.kotlin.fir.expressions.FirLazyExpression
 import org.jetbrains.kotlin.fir.renderer.FirRenderer
@@ -36,7 +36,7 @@ abstract class AbstractFirLazyBodiesCalculatorTest : AbstractLowLevelApiSingleFi
             val session = firResolveSession.useSiteFirSession
             val provider = session.kotlinScopeProvider
 
-            val laziedFirFile = RawFirBuilder(
+            val laziedFirFile = PsiRawFirBuilder(
                 session,
                 provider,
                 bodyBuildingMode = BodyBuildingMode.LAZY_BODIES
@@ -45,7 +45,7 @@ abstract class AbstractFirLazyBodiesCalculatorTest : AbstractLowLevelApiSingleFi
             FirLazyBodiesCalculator.calculateAllLazyExpressionsInFile(laziedFirFile)
             laziedFirFile.accept(lazyChecker)
 
-            val fullFirFile = RawFirBuilder(
+            val fullFirFile = PsiRawFirBuilder(
                 session,
                 provider,
                 bodyBuildingMode = BodyBuildingMode.NORMAL

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractPartialRawFirBuilderTestCase.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.test.configurators.Analys
 import org.jetbrains.kotlin.analysis.low.level.api.fir.test.configurators.AnalysisApiFirSourceTestConfigurator
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.renderer.ConeIdFullRenderer
@@ -117,7 +117,7 @@ abstract class AbstractPartialRawFirBuilderTestCase : AbstractLowLevelApiSingleF
         }
 
         val session = FirSessionFactoryHelper.createEmptySession()
-        val firBuilder = RawFirBuilder(session, scopeProvider)
+        val firBuilder = PsiRawFirBuilder(session, scopeProvider)
         val original = firBuilder.buildFirFile(file)
 
         val designationBuilder = DesignationBuilder(elementToBuild)

benchmarks/src/org/jetbrains/kotlin/benchmarks/AbstractSimpleFileBenchmark.kt

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.fir.FirTestSessionFactoryHelper
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
@@ -156,7 +156,7 @@ abstract class AbstractSimpleFileBenchmark {
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
         val session = FirTestSessionFactoryHelper.createSessionForTests(env.toAbstractProjectEnvironment(), scope.toAbstractProjectFileSearchScope())
         val firProvider = session.firProvider as FirProviderImpl
-        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
+        val builder = PsiRawFirBuilder(session, firProvider.kotlinScopeProvider)
 
         val totalTransformer = FirTotalResolveProcessor(session)
         val firFile = builder.buildFirFile(file).also(firProvider::recordFile)

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/firUtils.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.KtSourceFile
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
@@ -47,7 +47,7 @@ fun FirSession.buildFirViaLightTree(
 
 fun FirSession.buildFirFromKtFiles(ktFiles: Collection<KtFile>): List<FirFile> {
     val firProvider = (firProvider as FirProviderImpl)
-    val builder = RawFirBuilder(this, firProvider.kotlinScopeProvider)
+    val builder = PsiRawFirBuilder(this, firProvider.kotlinScopeProvider)
     return ktFiles.map {
         builder.buildFirFile(it).also { firFile ->
             firProvider.recordFile(firFile)

compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/FirResolveModularizedTotalKotlinTest.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
 import org.jetbrains.kotlin.fir.analysis.collectors.FirDiagnosticsCollector
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.dump.MultiModuleHtmlFirDump
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
@@ -35,12 +35,10 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveP
 import org.jetbrains.kotlin.fir.resolve.transformers.createAllCompilerResolveProcessors
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
-import sun.management.ManagementFactoryHelper
 import java.io.File
 import java.io.FileOutputStream
 import java.io.PrintStream
 import java.lang.management.ManagementFactory
-import java.text.DecimalFormat
 
 
 private const val FAIL_FAST = true
@@ -139,7 +137,7 @@ class FirResolveModularizedTotalKotlinTest : AbstractFrontendModularizedTest() {
             val lightTree2Fir = LightTree2Fir(session, firProvider.kotlinScopeProvider, diagnosticsReporter = null)
             bench.buildFiles(lightTree2Fir, sourceFiles)
         } else {
-            val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
+            val builder = PsiRawFirBuilder(session, firProvider.kotlinScopeProvider)
             bench.buildFiles(builder, sourceFiles.map { it as KtPsiSourceFile })
         }
 

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/LightTree2Fir.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.languageVersionSettings
-import org.jetbrains.kotlin.fir.lightTree.converter.DeclarationsConverter
+import org.jetbrains.kotlin.fir.lightTree.converter.LightTreeRawFirDeclarationBuilder
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.lexer.KotlinLexer
 import org.jetbrains.kotlin.parsing.KotlinLightParser
@@ -87,7 +87,7 @@ class LightTree2Fir(
         sourceFile: KtSourceFile,
         linesMapping: KtSourceFileLinesMapping,
     ): FirFile {
-        return DeclarationsConverter(session, scopeProvider, lightTree)
+        return LightTreeRawFirDeclarationBuilder(session, scopeProvider, lightTree)
             .convertFile(lightTree.root, sourceFile, linesMapping)
     }
 

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/AbstractLightTreeRawFirBuilder.kt

@@ -13,20 +13,19 @@ import com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.*
 import org.jetbrains.kotlin.ElementTypeUtils.isExpression
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.builder.BaseFirBuilder
+import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilder
 import org.jetbrains.kotlin.fir.builder.Context
 import org.jetbrains.kotlin.fir.builder.escapedStringToCharacter
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImplWithoutSource
 import org.jetbrains.kotlin.lexer.KtToken
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.name.Name
-import kotlin.contracts.ExperimentalContracts
 
-abstract class BaseConverter(
+abstract class AbstractLightTreeRawFirBuilder(
     baseSession: FirSession,
     val tree: FlyweightCapableTreeStructure<LighterASTNode>,
     context: Context<LighterASTNode> = Context()
-) : BaseFirBuilder<LighterASTNode>(baseSession, context) {
+) : AbstractRawFirBuilder<LighterASTNode>(baseSession, context) {
     protected val implicitType = FirImplicitTypeRefImplWithoutSource
 
     override fun LighterASTNode.toFirSourceElement(kind: KtFakeSourceElementKind?): KtLightSourceElement {

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/LightTreeRawFirDeclarationBuilder.kt

@@ -60,14 +60,14 @@ import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
 import org.jetbrains.kotlin.utils.addToStdlib.runUnless
 
-class DeclarationsConverter(
+class LightTreeRawFirDeclarationBuilder(
     session: FirSession,
     internal val baseScopeProvider: FirScopeProvider,
     tree: FlyweightCapableTreeStructure<LighterASTNode>,
     context: Context<LighterASTNode> = Context(),
-) : BaseConverter(session, tree, context) {
+) : AbstractLightTreeRawFirBuilder(session, tree, context) {
 
-    private val expressionConverter = ExpressionsConverter(session, tree, this, context)
+    private val expressionConverter = LightTreeRawFirExpressionBuilder(session, tree, this, context)
 
     /**
      * [org.jetbrains.kotlin.parsing.KotlinParsing.parseFile]

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/LightTreeRawFirExpressionBuilder.kt

@@ -54,12 +54,12 @@ import org.jetbrains.kotlin.psi.stubs.elements.KtNameReferenceExpressionElementT
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-class ExpressionsConverter(
+class LightTreeRawFirExpressionBuilder(
     session: FirSession,
     tree: FlyweightCapableTreeStructure<LighterASTNode>,
-    private val declarationsConverter: DeclarationsConverter,
+    private val declarationBuilder: LightTreeRawFirDeclarationBuilder,
     context: Context<LighterASTNode> = Context(),
-) : BaseConverter(session, tree, context) {
+) : AbstractLightTreeRawFirBuilder(session, tree, context) {
 
     inline fun <reified R : FirElement> getAsFirExpression(expression: LighterASTNode?, errorReason: String = ""): R {
         val converted = expression?.let { convertExpression(it, errorReason) }
@@ -113,9 +113,9 @@ class ExpressionsConverter(
             THIS_EXPRESSION -> convertThisExpression(expression)
             SUPER_EXPRESSION -> convertSuperExpression(expression)
 
-            OBJECT_LITERAL -> declarationsConverter.convertObjectLiteral(expression)
-            FUN -> declarationsConverter.convertFunctionDeclaration(expression)
-            DESTRUCTURING_DECLARATION -> declarationsConverter.convertDestructingDeclaration(expression).toFirDestructingDeclaration(baseModuleData)
+            OBJECT_LITERAL -> declarationBuilder.convertObjectLiteral(expression)
+            FUN -> declarationBuilder.convertFunctionDeclaration(expression)
+            DESTRUCTURING_DECLARATION -> declarationBuilder.convertDestructingDeclaration(expression).toFirDestructingDeclaration(baseModuleData)
             else -> buildErrorExpression(null, ConeSimpleDiagnostic(errorReason, DiagnosticKind.ExpressionExpected))
         }
     }
@@ -132,7 +132,7 @@ class ExpressionsConverter(
         val functionSymbol = FirAnonymousFunctionSymbol()
         lambdaExpression.getChildNodesByType(FUNCTION_LITERAL).first().forEachChildren {
             when (it.tokenType) {
-                VALUE_PARAMETER_LIST -> valueParameterList += declarationsConverter.convertValueParameters(it, functionSymbol, ValueParameterDeclaration.LAMBDA)
+                VALUE_PARAMETER_LIST -> valueParameterList += declarationBuilder.convertValueParameters(it, functionSymbol, ValueParameterDeclaration.LAMBDA)
                 BLOCK -> block = it
                 ARROW -> hasArrow = true
             }
@@ -188,7 +188,7 @@ class ExpressionsConverter(
             }
 
             body = if (block != null) {
-                declarationsConverter.convertBlockExpressionWithoutBuilding(block!!).apply {
+                declarationBuilder.convertBlockExpressionWithoutBuilding(block!!).apply {
                     statements.firstOrNull()?.let {
                         if (it.isContractBlockFirCheck()) {
                             this@buildAnonymousFunction.contractDescription = it.toLegacyRawContractDescription()
@@ -326,7 +326,7 @@ class ExpressionsConverter(
         binaryExpression.forEachChildren {
             when (it.tokenType) {
                 OPERATION_REFERENCE -> operationTokenName = it.asText
-                TYPE_REFERENCE -> firType = declarationsConverter.convertType(it)
+                TYPE_REFERENCE -> firType = declarationBuilder.convertType(it)
                 else -> if (it.isExpression()) leftArgAsFir = getAsFirExpression(it, "No left operand")
             }
         }
@@ -361,8 +361,8 @@ class ExpressionsConverter(
                     context.addNewLabel(pair.first)
                     errorLabelSource = pair.second
                 }
-                BLOCK -> firExpression = declarationsConverter.convertBlock(it)
-                PROPERTY -> firExpression = declarationsConverter.convertPropertyDeclaration(it)
+                BLOCK -> firExpression = declarationBuilder.convertBlock(it)
+                PROPERTY -> firExpression = declarationBuilder.convertPropertyDeclaration(it)
                 else -> if (it.isExpression()) firExpression = getAsFirExpression(it)
             }
         }
@@ -436,9 +436,9 @@ class ExpressionsConverter(
         val firAnnotationList = mutableListOf<FirAnnotation>()
         annotatedExpression.forEachChildren {
             when (it.tokenType) {
-                ANNOTATION -> firAnnotationList += declarationsConverter.convertAnnotation(it)
-                ANNOTATION_ENTRY -> firAnnotationList += declarationsConverter.convertAnnotationEntry(it)
-                BLOCK -> firExpression = declarationsConverter.convertBlockExpression(it)
+                ANNOTATION -> firAnnotationList += declarationBuilder.convertAnnotation(it)
+                ANNOTATION_ENTRY -> firAnnotationList += declarationBuilder.convertAnnotationEntry(it)
+                BLOCK -> firExpression = declarationBuilder.convertBlockExpression(it)
                 else -> if (it.isExpression()) {
                     context.forwardLabelUsagePermission(annotatedExpression, it)
                     firExpression = getAsFirExpression(it)
@@ -604,7 +604,7 @@ class ExpressionsConverter(
                         additionalArgument = getAsFirExpression(node, "Incorrect invoke receiver")
                     }
                     TYPE_ARGUMENT_LIST -> {
-                        firTypeArguments += declarationsConverter.convertTypeArguments(node, allowedUnderscoredTypeArgument = true)
+                        firTypeArguments += declarationBuilder.convertTypeArguments(node, allowedUnderscoredTypeArgument = true)
                     }
                     VALUE_ARGUMENT_LIST, LAMBDA_ARGUMENT -> {
                         hasArguments = true
@@ -713,7 +713,7 @@ class ExpressionsConverter(
         val whenEntries = mutableListOf<WhenEntry>()
         whenExpression.forEachChildren {
             when (it.tokenType) {
-                PROPERTY -> subjectVariable = (declarationsConverter.convertPropertyDeclaration(it) as FirVariable).let { variable ->
+                PROPERTY -> subjectVariable = (declarationBuilder.convertPropertyDeclaration(it) as FirVariable).let { variable ->
                     buildProperty {
                         source = it.toFirSourceElement()
                         origin = FirDeclarationOrigin.Source
@@ -810,8 +810,8 @@ class ExpressionsConverter(
                     shouldBindSubject = shouldBindSubject || shouldBind
                 }
                 ELSE_KEYWORD -> isElse = true
-                BLOCK -> firBlock = declarationsConverter.convertBlock(it)
-                else -> if (it.isExpression()) firBlock = declarationsConverter.convertBlock(it)
+                BLOCK -> firBlock = declarationBuilder.convertBlock(it)
+                else -> if (it.isExpression()) firBlock = declarationBuilder.convertBlock(it)
             }
         }
 
@@ -916,7 +916,7 @@ class ExpressionsConverter(
         var firType: FirTypeRef? = null
         whenCondition.forEachChildren {
             when (it.tokenType) {
-                TYPE_REFERENCE -> firType = declarationsConverter.convertType(it)
+                TYPE_REFERENCE -> firType = declarationBuilder.convertType(it)
                 IS_KEYWORD -> firOperation = FirOperation.IS
                 NOT_IS -> firOperation = FirOperation.NOT_IS
             }
@@ -1101,7 +1101,7 @@ class ExpressionsConverter(
         var blockNode: LighterASTNode? = null
         forLoop.forEachChildren {
             when (it.tokenType) {
-                VALUE_PARAMETER -> parameter = declarationsConverter.convertValueParameter(it, null, ValueParameterDeclaration.FOR_LOOP)
+                VALUE_PARAMETER -> parameter = declarationBuilder.convertValueParameter(it, null, ValueParameterDeclaration.FOR_LOOP)
                 LOOP_RANGE -> rangeExpression = getAsFirExpression(it, "No range in for loop")
                 BODY -> blockNode = it
             }
@@ -1190,7 +1190,7 @@ class ExpressionsConverter(
         var firStatement: FirStatement? = null
         body?.forEachChildren {
             when (it.tokenType) {
-                BLOCK -> firBlock = declarationsConverter.convertBlockExpression(it)
+                BLOCK -> firBlock = declarationBuilder.convertBlockExpression(it)
                 ANNOTATED_EXPRESSION -> {
                     if (it.getChildNodeByType(BLOCK) != null) {
                         firBlock = getAsFirExpression(it)
@@ -1215,7 +1215,7 @@ class ExpressionsConverter(
         var finallyBlock: FirBlock? = null
         tryExpression.forEachChildren {
             when (it.tokenType) {
-                BLOCK -> tryBlock = declarationsConverter.convertBlock(it)
+                BLOCK -> tryBlock = declarationBuilder.convertBlock(it)
                 CATCH -> convertCatchClause(it)?.also { oneClause -> catchClauses += oneClause }
                 FINALLY -> finallyBlock = convertFinally(it)
             }
@@ -1256,13 +1256,13 @@ class ExpressionsConverter(
         var blockNode: LighterASTNode? = null
         catchClause.forEachChildren {
             when (it.tokenType) {
-                VALUE_PARAMETER_LIST -> valueParameter = declarationsConverter.convertValueParameters(it, FirAnonymousFunctionSymbol()/*TODO*/, ValueParameterDeclaration.CATCH)
+                VALUE_PARAMETER_LIST -> valueParameter = declarationBuilder.convertValueParameters(it, FirAnonymousFunctionSymbol()/*TODO*/, ValueParameterDeclaration.CATCH)
                     .firstOrNull() ?: return null
                 BLOCK -> blockNode = it
             }
         }
 
-        return Triple(valueParameter, declarationsConverter.convertBlock(blockNode), catchClause.toFirSourceElement())
+        return Triple(valueParameter, declarationBuilder.convertBlock(blockNode), catchClause.toFirSourceElement())
     }
 
     /**
@@ -1276,7 +1276,7 @@ class ExpressionsConverter(
             }
         }
 
-        return declarationsConverter.convertBlock(blockNode)
+        return declarationBuilder.convertBlock(blockNode)
     }
 
     /**
@@ -1442,7 +1442,7 @@ class ExpressionsConverter(
         var superTypeRef: FirTypeRef = implicitType
         superExpression.forEachChildren {
             when (it.tokenType) {
-                TYPE_REFERENCE -> superTypeRef = declarationsConverter.convertType(it)
+                TYPE_REFERENCE -> superTypeRef = declarationBuilder.convertType(it)
             }
         }
 

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/PsiRawFirBuilder.kt

@@ -51,11 +51,11 @@ import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
 import org.jetbrains.kotlin.utils.addToStdlib.shouldNotBeCalled
 
-open class RawFirBuilder(
+open class PsiRawFirBuilder(
     session: FirSession,
     val baseScopeProvider: FirScopeProvider,
     bodyBuildingMode: BodyBuildingMode = BodyBuildingMode.NORMAL
-) : BaseFirBuilder<PsiElement>(session) {
+) : AbstractRawFirBuilder<PsiElement>(session) {
     protected open fun bindFunctionTarget(target: FirFunctionTarget, function: FirFunction) = target.bind(function)
     protected open fun FirFunctionBuilder.additionalFunctionInit() {}
     protected open fun FirPropertyBuilder.additionalPropertyInit() {}
@@ -87,7 +87,7 @@ open class RawFirBuilder(
     }
 
     override fun PsiElement.toFirSourceElement(kind: KtFakeSourceElementKind?): KtPsiSourceElement {
-        val actualKind = kind ?: this@RawFirBuilder.context.forcedElementSourceKind ?: KtRealSourceElementKind
+        val actualKind = kind ?: this@PsiRawFirBuilder.context.forcedElementSourceKind ?: KtRealSourceElementKind
         return this.toKtPsiSourceElement(actualKind)
     }
 
@@ -458,7 +458,7 @@ open class RawFirBuilder(
                         this.status = status
                         annotations += accessorAnnotationsFromProperty
                         extractAnnotationsTo(this)
-                        this@RawFirBuilder.context.firFunctionTargets += accessorTarget
+                        this@PsiRawFirBuilder.context.firFunctionTargets += accessorTarget
                         symbol = FirPropertyAccessorSymbol()
                         extractValueParametersTo(
                             this, symbol, ValueParameterDeclaration.SETTER, propertyTypeRefToUse, parameterAnnotationsFromProperty
@@ -486,7 +486,7 @@ open class RawFirBuilder(
                     }.also {
                         it.initContainingClassAttr()
                         bindFunctionTarget(accessorTarget, it)
-                        this@RawFirBuilder.context.firFunctionTargets.removeLast()
+                        this@PsiRawFirBuilder.context.firFunctionTargets.removeLast()
                     }
                 }
                 isGetter || property.isVar -> {
@@ -629,7 +629,7 @@ open class RawFirBuilder(
             require(hasValOrVar())
             val type = typeReference.convertSafe<FirTypeRef>() ?: createNoTypeForParameterTypeRef()
             val status = FirDeclarationStatusImpl(visibility, modality).apply {
-                isExpect = hasExpectModifier() || this@RawFirBuilder.context.containerIsExpect
+                isExpect = hasExpectModifier() || this@PsiRawFirBuilder.context.containerIsExpect
                 isActual = hasActualModifier()
                 isOverride = hasModifier(OVERRIDE_KEYWORD)
                 isConst = hasModifier(CONST_KEYWORD)
@@ -861,7 +861,7 @@ open class RawFirBuilder(
                 origin = FirDeclarationOrigin.Synthetic
                 name = NameUtils.delegateFieldName(fieldOrd)
                 returnTypeRef = type
-                symbol = FirFieldSymbol(CallableId(this@RawFirBuilder.context.currentClassId, name))
+                symbol = FirFieldSymbol(CallableId(this@PsiRawFirBuilder.context.currentClassId, name))
                 isVar = false
                 status = FirDeclarationStatusImpl(Visibilities.Private, Modality.FINAL)
                 initializer = delegateExpression
@@ -1018,7 +1018,7 @@ open class RawFirBuilder(
 
             val explicitVisibility = this?.visibility?.takeUnless { it == Visibilities.Unknown }
             val status = FirDeclarationStatusImpl(explicitVisibility ?: defaultVisibility(), Modality.FINAL).apply {
-                isExpect = this@toFirConstructor?.hasExpectModifier() == true || this@RawFirBuilder.context.containerIsExpect
+                isExpect = this@toFirConstructor?.hasExpectModifier() == true || this@PsiRawFirBuilder.context.containerIsExpect
                 isActual = this@toFirConstructor?.hasActualModifier() == true
                 isInner = owner.hasModifier(INNER_KEYWORD)
                 isFromSealedClass = owner.hasModifier(SEALED_KEYWORD) && explicitVisibility !== Visibilities.Private
@@ -1144,7 +1144,7 @@ open class RawFirBuilder(
             ownerClassHasDefaultConstructor: Boolean
         ): FirDeclaration {
             val ktEnumEntry = this@toFirEnumEntry
-            val containingClassIsExpectClass = hasExpectModifier() || this@RawFirBuilder.context.containerIsExpect
+            val containingClassIsExpectClass = hasExpectModifier() || this@PsiRawFirBuilder.context.containerIsExpect
             return buildEnumEntry {
                 source = toFirSourceElement()
                 moduleData = baseModuleData
@@ -1172,7 +1172,7 @@ open class RawFirBuilder(
                                 moduleData = baseModuleData
                                 origin = FirDeclarationOrigin.Source
                                 classKind = ClassKind.ENUM_ENTRY
-                                scopeProvider = this@RawFirBuilder.baseScopeProvider
+                                scopeProvider = this@PsiRawFirBuilder.baseScopeProvider
                                 symbol = FirAnonymousObjectSymbol()
                                 status = FirDeclarationStatusImpl(Visibilities.Local, Modality.FINAL)
 
@@ -1702,7 +1702,7 @@ open class RawFirBuilder(
                 returnTypeRef = selfTypeRef
                 val explicitVisibility = visibility
                 status = FirDeclarationStatusImpl(explicitVisibility, Modality.FINAL).apply {
-                    isExpect = hasExpectModifier() || this@RawFirBuilder.context.containerIsExpect
+                    isExpect = hasExpectModifier() || this@PsiRawFirBuilder.context.containerIsExpect
                     isActual = hasActualModifier()
                     isInner = owner.hasModifier(INNER_KEYWORD)
                     isFromSealedClass = owner.hasModifier(SEALED_KEYWORD) && explicitVisibility !== Visibilities.Private
@@ -1717,7 +1717,7 @@ open class RawFirBuilder(
                 ) {
                     getDelegationCall().convert(delegatedTypeRef)
                 }
-                this@RawFirBuilder.context.firFunctionTargets += target
+                this@PsiRawFirBuilder.context.firFunctionTargets += target
                 extractAnnotationsTo(this)
                 typeParameters += constructorTypeParametersFromConstructedClass(ownerTypeParameters)
                 extractValueParametersTo(this, symbol, ValueParameterDeclaration.FUNCTION)
@@ -1726,7 +1726,7 @@ open class RawFirBuilder(
                 val (body, contractDescription) = buildFirBody()
                 contractDescription?.let { this.contractDescription = it }
                 this.body = body
-                this@RawFirBuilder.context.firFunctionTargets.removeLast()
+                this@PsiRawFirBuilder.context.firFunctionTargets.removeLast()
             }.also {
                 it.containingClassForStaticMemberAttr = currentDispatchReceiverType()!!.lookupTag
                 bindFunctionTarget(target, it)
@@ -1766,13 +1766,13 @@ open class RawFirBuilder(
 
         private fun KtDeclarationWithInitializer.toInitializerExpression() =
             runIf(hasInitializer()) {
-                this@RawFirBuilder.context.calleeNamesForLambda += null
+                this@PsiRawFirBuilder.context.calleeNamesForLambda += null
 
                 val expression = buildOrLazyExpression(null) {
                     initializer.toFirExpression("Should have initializer")
                 }
 
-                this@RawFirBuilder.context.calleeNamesForLambda.removeLast()
+                this@PsiRawFirBuilder.context.calleeNamesForLambda.removeLast()
                 expression
             }
 
@@ -1867,7 +1867,7 @@ open class RawFirBuilder(
                         )
 
                         status = FirDeclarationStatusImpl(visibility, modality).apply {
-                            isExpect = hasExpectModifier() || this@RawFirBuilder.context.containerIsExpect
+                            isExpect = hasExpectModifier() || this@PsiRawFirBuilder.context.containerIsExpect
                             isActual = hasActualModifier()
                             isOverride = hasModifier(OVERRIDE_KEYWORD)
                             isConst = hasModifier(CONST_KEYWORD)

compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt

@@ -80,7 +80,7 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
 
     protected fun KtFile.toFirFile(bodyBuildingMode: BodyBuildingMode = BodyBuildingMode.NORMAL): FirFile {
         val session = FirSessionFactoryHelper.createEmptySession()
-        return RawFirBuilder(
+        return PsiRawFirBuilder(
             session,
             StubFirScopeProvider,
             bodyBuildingMode = bodyBuildingMode

compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilder.kt

@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.types.ConstantValueKind
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 //T can be either PsiElement, or LighterASTNode
-abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Context<T> = Context()) {
+abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context: Context<T> = Context()) {
     val baseModuleData: FirModuleData = baseSession.moduleData
 
     abstract fun T.toFirSourceElement(kind: KtFakeSourceElementKind? = null): KtSourceElement

compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirBaseDiagnosticsTest.kt

@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.KtDiagnostic
 import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils
 import org.jetbrains.kotlin.fir.builder.BodyBuildingMode
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
@@ -138,7 +138,7 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() {
                 firFile
             }
         } else {
-            val firBuilder = RawFirBuilder(
+            val firBuilder = PsiRawFirBuilder(
                 session,
                 firProvider.kotlinScopeProvider,
                 bodyBuildingMode = BodyBuildingMode.lazyBodies(useLazyBodiesModeForRawFir)

compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt

@@ -7,19 +7,15 @@ package org.jetbrains.kotlin.fir
 import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.KtIoFileSourceFile
 import org.jetbrains.kotlin.KtPsiSourceFile
 import org.jetbrains.kotlin.KtSourceFile
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.diagnostics.ConeStubDiagnostic
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
-import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
-import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
 import org.jetbrains.kotlin.fir.references.isError
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
@@ -32,7 +28,6 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.readSourceFileWithMapping
 import org.jetbrains.kotlin.utils.addToStdlib.sumByLong
-import java.io.File
 import java.io.PrintStream
 import java.text.DecimalFormat
 import kotlin.math.max
@@ -114,7 +109,7 @@ class FirResolveBench(val withProgress: Boolean, val listener: BenchListener? =
     private val errorTypesReports = mutableMapOf<String, ErrorTypeReport>()
 
     fun buildFiles(
-        builder: RawFirBuilder,
+        builder: PsiRawFirBuilder,
         files: Collection<KtPsiSourceFile>
     ): List<FirFile> {
         listener?.before()

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/FirAnalyzerFacade.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.analysis.collectors.FirDiagnosticsCollector
 import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.backend.jvm.Fir2IrJvmSpecialAnnotationSymbolProvider
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmVisibilityConverter
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.builder.PsiRawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -70,7 +70,7 @@ class FirAnalyzerFacade(
                 }
             }
             FirParser.Psi -> {
-                val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
+                val builder = PsiRawFirBuilder(session, firProvider.kotlinScopeProvider)
                 ktFiles.map {
                     builder.buildFirFile(it).also { firFile ->
                         firProvider.recordFile(firFile)