[FIR] Implement builders for leaf nodes of FIR tree

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -16,8 +16,8 @@ import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.FirSuperReference
+import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirPropertyFromParameterResolvedNamedReference
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.SyntheticPropertySymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.IntegerLiteralTypeApproximationTransformer
@@ -902,15 +902,15 @@ class Fir2IrVisitor(
         if (functionCall !is FirFunctionCallImpl) {
             return functionCall
         }
-        val calleeReference = (functionCall.calleeReference as? FirResolvedNamedReferenceImpl) ?: return functionCall
+        val calleeReference = (functionCall.calleeReference as? FirResolvedNamedReference) ?: return functionCall
         val resolvedSymbol = (calleeReference.resolvedSymbol as? FirNamedFunctionSymbol) ?: return functionCall
         if (resolvedSymbol.callableId.isInvoke()) {
             functionCall.calleeReference =
-                FirResolvedNamedReferenceImpl(
-                    source = calleeReference.source,
-                    name = calleeReference.name,
-                    resolvedSymbol = resolvedSymbol.overriddenSymbol!!
-                )
+                buildResolvedNamedReference {
+                    source = calleeReference.source
+                    name = calleeReference.name
+                    this.resolvedSymbol = resolvedSymbol.overriddenSymbol!!
+                }
         }
         return functionCall
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt

@@ -15,21 +15,19 @@ import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary
-import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
-import org.jetbrains.kotlin.fir.declarations.visibility
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
-import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder
+import org.jetbrains.kotlin.fir.java.declarations.*
+import org.jetbrains.kotlin.fir.resolve.AbstractFirSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.impl.*
+import org.jetbrains.kotlin.fir.scopes.impl.lazyNestedClassifierScope
+import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeNullability
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.structure.JavaClass
@@ -45,7 +43,7 @@ import org.jetbrains.kotlin.types.Variance.INVARIANT
 class JavaSymbolProvider(
     val session: FirSession,
     val project: Project,
-    private val searchScope: GlobalSearchScope
+    private val searchScope: GlobalSearchScope,
 ) : AbstractFirSymbolProvider<FirRegularClassSymbol>() {
 
     private val scopeProvider = JavaScopeProvider(::wrapScopeWithJvmMapped, this)
@@ -54,7 +52,7 @@ class JavaSymbolProvider(
 
     private fun findClass(
         classId: ClassId,
-        content: KotlinClassFinder.Result.ClassFileContent?
+        content: KotlinClassFinder.Result.ClassFileContent?,
     ): JavaClass? = facade.findClass(JavaClassFinder.Request(classId, previouslyFoundClassFileContent = content?.content), searchScope)
 
     override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> =
@@ -67,34 +65,31 @@ class JavaSymbolProvider(
             lazyNestedClassifierScope(
                 classId,
                 existingNames = regularClass.existingNestedClassifierNames,
-                symbolProvider = this
+                symbolProvider = this,
             )
         } else {
             nestedClassifierScope(regularClass)
         }
     }
 
-    private fun JavaTypeParameter.toFirTypeParameter(javaTypeParameterStack: JavaTypeParameterStack): FirTypeParameter {
-        val stored = javaTypeParameterStack.safeGet(this)
-        if (stored != null) return stored.fir
+    private fun JavaTypeParameter.toFirTypeParameter(javaTypeParameterStack: JavaTypeParameterStack): FirTypeParameterBuilder {
+        javaTypeParameterStack.getBuilder(this)?.let { return it }
         val firSymbol = FirTypeParameterSymbol()
-        val result = FirTypeParameterImpl(
-            null,
-            session,
-            name,
-            firSymbol,
-            variance = INVARIANT,
+        return FirTypeParameterBuilder().apply {
+            session = this@JavaSymbolProvider.session
+            name = this@toFirTypeParameter.name
+            symbol = firSymbol
+            variance = INVARIANT
             isReified = false
-        )
-        javaTypeParameterStack.add(this, result)
-        return result
+        }.also {
+            javaTypeParameterStack.add(this, it)
+        }
     }
 
-    private fun FirTypeParameter.addBounds(
+    private fun FirTypeParameterBuilder.addBounds(
         javaTypeParameter: JavaTypeParameter,
-        stack: JavaTypeParameterStack
+        stack: JavaTypeParameterStack,
     ) {
-        require(this is FirTypeParameterImpl)
         for (upperBound in javaTypeParameter.upperBounds) {
             bounds += upperBound.toFirResolvedTypeRef(this@JavaSymbolProvider.session, stack, nullability = ConeNullability.NULLABLE)
         }
@@ -104,12 +99,11 @@ class JavaSymbolProvider(
     private fun List<JavaTypeParameter>.convertTypeParameters(stack: JavaTypeParameterStack): List<FirTypeParameter> {
         return this
             .map { it.toFirTypeParameter(stack) }
-            .also {
-                it.forEachIndexed { index, typeParameter ->
-                    if (typeParameter.bounds.isEmpty()) {
-                        typeParameter.addBounds(this[index], stack)
-                    }
+            .mapIndexed { index, typeParameterBuilder ->
+                if (typeParameterBuilder.bounds.isEmpty()) {
+                    typeParameterBuilder.addBounds(this[index], stack)
                 }
+                typeParameterBuilder.build()
             }
     }
 
@@ -123,14 +117,17 @@ class JavaSymbolProvider(
 
     fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): FirRegularClassSymbol? {
         if (!hasTopLevelClassOf(classId)) return null
-        return classCache.lookupCacheOrCalculateWithPostCompute(classId, {
-            val foundClass = findClass(classId, content)
-            if (foundClass == null || foundClass.annotations.any { it.classId?.asSingleFqName() == JvmAnnotationNames.METADATA_FQ_NAME }) {
-                null to null
-            } else {
-                FirRegularClassSymbol(classId) to foundClass
-            }
-        }) { firSymbol, foundClass ->
+        return classCache.lookupCacheOrCalculateWithPostCompute(
+            classId,
+            {
+                val foundClass = findClass(classId, content)
+                if (foundClass == null || foundClass.annotations.any { it.classId?.asSingleFqName() == JvmAnnotationNames.METADATA_FQ_NAME }) {
+                    null to null
+                } else {
+                    FirRegularClassSymbol(classId) to foundClass
+                }
+            },
+        ) { firSymbol, foundClass ->
             foundClass?.let { javaClass ->
                 val javaTypeParameterStack = JavaTypeParameterStack()
                 val parentFqName = classId.relativeClassName.parent()
@@ -143,17 +140,20 @@ class JavaSymbolProvider(
                         javaTypeParameterStack.addStack(parentClass.javaTypeParameterStack)
                     }
                 }
-                FirJavaClass(
-                    (javaClass as? JavaElementImpl<*>)?.psi?.toFirSourceElement(), session,
-                    firSymbol, javaClass.name,
-                    javaClass.visibility, javaClass.modality,
-                    javaClass.classKind, isTopLevel = isTopLevel,
-                    isStatic = javaClass.isStatic,
-                    javaTypeParameterStack = javaTypeParameterStack,
-                    existingNestedClassifierNames = javaClass.innerClassNames.toList(),
-                    scopeProvider = scopeProvider
-                ).apply {
-                    this.typeParameters += foundClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
+                buildJavaClass {
+                    source = (javaClass as? JavaElementImpl<*>)?.psi?.toFirSourceElement()
+                    session = this@JavaSymbolProvider.session
+                    symbol = firSymbol
+                    name = javaClass.name
+                    visibility = javaClass.visibility
+                    modality = javaClass.modality
+                    classKind = javaClass.classKind
+                    this.isTopLevel = isTopLevel
+                    isStatic = javaClass.isStatic
+                    this.javaTypeParameterStack = javaTypeParameterStack
+                    existingNestedClassifierNames += javaClass.innerClassNames
+                    scopeProvider = this@JavaSymbolProvider.scopeProvider
+                    typeParameters += foundClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
                     addAnnotationsFrom(this@JavaSymbolProvider.session, javaClass, javaTypeParameterStack)
                     for (supertype in javaClass.supertypes) {
                         superTypeRefs += supertype.toFirResolvedTypeRef(
@@ -167,14 +167,16 @@ class JavaSymbolProvider(
                         val fieldId = CallableId(classId.packageFqName, classId.relativeClassName, fieldName)
                         val fieldSymbol = FirFieldSymbol(fieldId)
                         val returnType = javaField.type
-                        val firJavaField = FirJavaField(
-                            (javaField as? JavaElementImpl<*>)?.psi?.toFirSourceElement(), this@JavaSymbolProvider.session,
-                            fieldSymbol, fieldName,
-                            javaField.visibility, javaField.modality,
-                            returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack),
-                            isVar = !javaField.isFinal,
+                        val firJavaField = buildJavaField {
+                            source = (javaField as? JavaElementImpl<*>)?.psi?.toFirSourceElement()
+                            session = this@JavaSymbolProvider.session
+                            symbol = fieldSymbol
+                            name = fieldName
+                            visibility = javaField.visibility
+                            modality = javaField.modality
+                            returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack)
+                            isVar = !javaField.isFinal
                             isStatic = javaField.isStatic
-                        ).apply {
                             addAnnotationsFrom(this@JavaSymbolProvider.session, javaField, javaTypeParameterStack)
                         }
                         declarations += firJavaField
@@ -184,18 +186,20 @@ class JavaSymbolProvider(
                         val methodId = CallableId(classId.packageFqName, classId.relativeClassName, methodName)
                         val methodSymbol = FirNamedFunctionSymbol(methodId)
                         val returnType = javaMethod.returnType
-                        val firJavaMethod = FirJavaMethod(
-                            this@JavaSymbolProvider.session, (javaMethod as? JavaElementImpl<*>)?.psi?.toFirSourceElement(),
-                            methodSymbol, methodName,
-                            javaMethod.visibility, javaMethod.modality,
-                            returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack),
+                        val firJavaMethod = buildJavaMethod {
+                            session = this@JavaSymbolProvider.session
+                            source = (javaMethod as? JavaElementImpl<*>)?.psi?.toFirSourceElement()
+                            symbol = methodSymbol
+                            name = methodName
+                            visibility = javaMethod.visibility
+                            modality = javaMethod.modality
+                            returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack)
                             isStatic = javaMethod.isStatic
-                        ).apply {
-                            this.typeParameters += javaMethod.typeParameters.convertTypeParameters(javaTypeParameterStack)
+                            typeParameters += javaMethod.typeParameters.convertTypeParameters(javaTypeParameterStack)
                             addAnnotationsFrom(this@JavaSymbolProvider.session, javaMethod, javaTypeParameterStack)
                             for ((index, valueParameter) in javaMethod.valueParameters.withIndex()) {
                                 valueParameters += valueParameter.toFirValueParameter(
-                                    this@JavaSymbolProvider.session, index, javaTypeParameterStack
+                                    this@JavaSymbolProvider.session, index, javaTypeParameterStack,
                                 )
                             }
                         }
@@ -204,56 +208,53 @@ class JavaSymbolProvider(
                     val javaClassDeclaredConstructors = javaClass.constructors
                     val constructorId = CallableId(classId.packageFqName, classId.relativeClassName, classId.shortClassName)
 
-                    fun addJavaConstructor(
+                    fun prepareJavaConstructor(
                         visibility: Visibility = this.visibility,
                         psi: PsiElement? = null,
-                        isPrimary: Boolean = false
-                    ): FirJavaConstructor {
+                        isPrimary: Boolean = false,
+                    ): FirJavaConstructorBuilder {
                         val constructorSymbol = FirConstructorSymbol(constructorId)
                         val classTypeParameters = javaClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
-                        val firJavaConstructor = FirJavaConstructor(
-                            psi?.toFirSourceElement(),
-                            this@JavaSymbolProvider.session,
-                            constructorSymbol,
-                            visibility,
-                            isPrimary,
-                            isInner = !javaClass.isStatic,
-                            returnTypeRef = FirResolvedTypeRefImpl(
-                                null,
-                                firSymbol.constructType(
+                        val firJavaConstructor = FirJavaConstructorBuilder().apply {
+                            source = psi?.toFirSourceElement()
+                            session = this@JavaSymbolProvider.session
+                            symbol = constructorSymbol
+                            this.visibility = visibility
+                            this.isPrimary = isPrimary
+                            isInner = !javaClass.isStatic
+                            returnTypeRef = buildResolvedTypeRef {
+                                type = firSymbol.constructType(
                                     classTypeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) }.toTypedArray(),
-                                    false
+                                    false,
                                 )
-                            )
-                        ).apply {
-                            this.typeParameters += classTypeParameters
+                            }
+                            typeParameters += classTypeParameters
                         }
-                        declarations += firJavaConstructor
                         return firJavaConstructor
                     }
 
                     if (javaClassDeclaredConstructors.isEmpty() && javaClass.classKind == ClassKind.CLASS) {
-                        addJavaConstructor(isPrimary = true)
+                        declarations += prepareJavaConstructor(isPrimary = true).build()
                     }
                     for (javaConstructor in javaClassDeclaredConstructors) {
-                        addJavaConstructor(
-                            visibility = javaConstructor.visibility, psi = (javaConstructor as? JavaElementImpl<*>)?.psi
+                        declarations += prepareJavaConstructor(
+                            visibility = javaConstructor.visibility, psi = (javaConstructor as? JavaElementImpl<*>)?.psi,
                         ).apply {
                             this.typeParameters += javaConstructor.typeParameters.convertTypeParameters(javaTypeParameterStack)
                             addAnnotationsFrom(this@JavaSymbolProvider.session, javaConstructor, javaTypeParameterStack)
                             for ((index, valueParameter) in javaConstructor.valueParameters.withIndex()) {
                                 valueParameters += valueParameter.toFirValueParameter(
-                                    this@JavaSymbolProvider.session, index, javaTypeParameterStack
+                                    this@JavaSymbolProvider.session, index, javaTypeParameterStack,
                                 )
                             }
-                        }
+                        }.build()
                     }
 
                     if (classKind == ClassKind.ENUM_CLASS) {
                         generateValuesFunction(session, classId.packageFqName, classId.relativeClassName)
                         generateValueOfFunction(session, classId.packageFqName, classId.relativeClassName)
                     }
-                    calculateSAM()
+                    isNotSam = isNotSam()
                 }
             }
         }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeParameterStack.kt

@@ -5,16 +5,16 @@
 
 package org.jetbrains.kotlin.fir.java
 
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter
 
 internal class JavaTypeParameterStack {
 
-    private val typeParameterMap = mutableMapOf<JavaTypeParameter, FirTypeParameterSymbol>()
+    private val typeParameterMap = mutableMapOf<JavaTypeParameter, FirTypeParameterBuilder>()
 
-    fun add(javaTypeParameter: JavaTypeParameter, firTypeParameter: FirTypeParameter) {
-        typeParameterMap[javaTypeParameter] = firTypeParameter.symbol
+    fun add(javaTypeParameter: JavaTypeParameter, firTypeParameterBuilder: FirTypeParameterBuilder) {
+        typeParameterMap[javaTypeParameter] = firTypeParameterBuilder
     }
 
     fun addStack(javaTypeParameterStack: JavaTypeParameterStack) {
@@ -30,7 +30,9 @@ internal class JavaTypeParameterStack {
             ?: throw IllegalArgumentException("Cannot find Java type parameter $javaTypeParameter in stack")
     }
 
-    fun safeGet(javaTypeParameter: JavaTypeParameter) = typeParameterMap[javaTypeParameter]
+    fun safeGet(javaTypeParameter: JavaTypeParameter) = typeParameterMap[javaTypeParameter]?.symbol
+
+    fun getBuilder(javaTypeParameter: JavaTypeParameter) = typeParameterMap[javaTypeParameter]
 
     companion object {
         val EMPTY: JavaTypeParameterStack = JavaTypeParameterStack()

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt

@@ -9,19 +9,21 @@ import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
+import org.jetbrains.kotlin.fir.expressions.FirConstKind
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.impl.*
-import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaValueParameter
+import org.jetbrains.kotlin.fir.expressions.builder.*
+import org.jetbrains.kotlin.fir.java.declarations.buildJavaValueParameter
 import org.jetbrains.kotlin.fir.java.enhancement.readOnlyToMutable
-import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
+import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
+import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.constructClassType
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.getClassDeclaredCallableSymbols
@@ -30,11 +32,11 @@ import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.toFirSourceElement
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
-import org.jetbrains.kotlin.fir.expressions.FirConstKind
+import org.jetbrains.kotlin.fir.types.jvm.buildJavaTypeRef
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.load.java.structure.impl.JavaElementImpl
 import org.jetbrains.kotlin.name.ClassId
@@ -84,10 +86,10 @@ internal fun JavaType?.toNotNullConeKotlinType(
 
 internal fun JavaType.toFirJavaTypeRef(session: FirSession, javaTypeParameterStack: JavaTypeParameterStack): FirJavaTypeRef {
     val annotations = (this as? JavaClassifierType)?.annotations.orEmpty()
-    return FirJavaTypeRef(
-        annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) },
-        type = this
-    )
+    return buildJavaTypeRef {
+        annotations.mapTo(this.annotations) { it.toFirAnnotationCall(session, javaTypeParameterStack) }
+        type = this@toFirJavaTypeRef
+    }
 }
 
 internal fun JavaClassifierType.toFirResolvedTypeRef(
@@ -97,10 +99,9 @@ internal fun JavaClassifierType.toFirResolvedTypeRef(
     typeParametersNullability: ConeNullability = ConeNullability.NOT_NULL
 ): FirResolvedTypeRef {
     val coneType = this.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, nullability, typeParametersNullability)
-    return FirResolvedTypeRefImpl(
-        source = null, type = coneType
-    ).apply {
-        annotations += this@toFirResolvedTypeRef.annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) }
+    return buildResolvedTypeRef {
+        type = coneType
+        this@toFirResolvedTypeRef.annotations.mapTo(annotations) { it.toFirAnnotationCall(session, javaTypeParameterStack) }
     }
 }
 
@@ -188,20 +189,18 @@ internal fun JavaClassifierType.toConeKotlinTypeWithNullability(
 internal fun JavaAnnotation.toFirAnnotationCall(
     session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
 ): FirAnnotationCall {
-    return FirAnnotationCallImpl(
-        source = null, useSiteTarget = null,
-        annotationTypeRef = FirResolvedTypeRefImpl(
-            source = null,
+    return buildAnnotationCall {
+        annotationTypeRef = buildResolvedTypeRef {
             type = ConeClassLikeTypeImpl(FirRegularClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false)
-        )
-    ).apply {
+        }
         for (argument in this@toFirAnnotationCall.arguments) {
             arguments += argument.toFirExpression(session, javaTypeParameterStack)
         }
     }
 }
 
-internal fun FirAbstractAnnotatedElement.addAnnotationsFrom(
+@FirBuilderDsl
+internal fun FirAnnotationContainerBuilder.addAnnotationsFrom(
     session: FirSession, javaAnnotationOwner: JavaAnnotationOwner, javaTypeParameterStack: JavaTypeParameterStack
 ) {
     for (annotation in javaAnnotationOwner.annotations) {
@@ -212,11 +211,12 @@ internal fun FirAbstractAnnotatedElement.addAnnotationsFrom(
 internal fun JavaValueParameter.toFirValueParameter(
     session: FirSession, index: Int, javaTypeParameterStack: JavaTypeParameterStack
 ): FirValueParameter {
-    return FirJavaValueParameter(
-        session, (this as? JavaElementImpl<*>)?.psi?.toFirSourceElement(), name ?: Name.identifier("p$index"),
-        returnTypeRef = type.toFirJavaTypeRef(session, javaTypeParameterStack),
-        isVararg = isVararg
-    ).apply {
+    return buildJavaValueParameter {
+        source = (this@toFirValueParameter as? JavaElementImpl<*>)?.psi?.toFirSourceElement()
+        this.session = session
+        name = this@toFirValueParameter.name ?: Name.identifier("p$index")
+        returnTypeRef = type.toFirJavaTypeRef(session, javaTypeParameterStack)
+        isVararg = this@toFirValueParameter.isVararg
         addAnnotationsFrom(session, this@toFirValueParameter, javaTypeParameterStack)
     }
 }
@@ -257,13 +257,13 @@ private fun JavaAnnotationArgument.toFirExpression(
         is JavaLiteralAnnotationArgument -> {
             value.createConstant(session)
         }
-        is JavaArrayAnnotationArgument -> FirArrayOfCallImpl(null).apply {
+        is JavaArrayAnnotationArgument -> buildArrayOfCall {
             for (element in getElements()) {
                 arguments += element.toFirExpression(session, javaTypeParameterStack)
             }
         }
         is JavaEnumValueAnnotationArgument -> {
-            FirFunctionCallImpl(null).apply {
+            buildFunctionCall {
                 val classId = this@toFirExpression.enumClassId
                 val entryName = this@toFirExpression.entryName
                 val calleeReference = if (classId != null && entryName != null) {
@@ -271,33 +271,36 @@ private fun JavaAnnotationArgument.toFirExpression(
                         classId, entryName
                     ).firstOrNull()
                     callableSymbol?.let {
-                        FirResolvedNamedReferenceImpl(null, entryName, it)
+                        buildResolvedNamedReference {
+                            name = entryName
+                            resolvedSymbol = it
+                        }
                     }
                 } else {
                     null
                 }
                 this.calleeReference = calleeReference
-                    ?: FirErrorNamedReferenceImpl(
-                        null, FirSimpleDiagnostic("Strange Java enum value: $classId.$entryName", DiagnosticKind.Java)
-                    )
+                    ?: buildErrorNamedReference {
+                        diagnostic = FirSimpleDiagnostic("Strange Java enum value: $classId.$entryName", DiagnosticKind.Java)
+                    }
             }
         }
-        is JavaClassObjectAnnotationArgument -> FirGetClassCallImpl(null).apply {
+        is JavaClassObjectAnnotationArgument -> buildGetClassCall {
             val referencedType = getReferencedType()
-            arguments += FirClassReferenceExpressionImpl(
-                null, referencedType.toFirResolvedTypeRef(session, javaTypeParameterStack)
-            )
+            arguments += buildClassReferenceExpression {
+                classTypeRef = referencedType.toFirResolvedTypeRef(session, javaTypeParameterStack)
+            }
         }
         is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session, javaTypeParameterStack)
-        else -> FirErrorExpressionImpl(
-            null, FirSimpleDiagnostic("Unknown JavaAnnotationArgument: ${this::class.java}", DiagnosticKind.Java)
-        )
+        else -> buildErrorExpression {
+            diagnostic = FirSimpleDiagnostic("Unknown JavaAnnotationArgument: ${this::class.java}", DiagnosticKind.Java)
+        }
     }
 }
 
 // TODO: use kind here
 private fun <T> List<T>.createArrayOfCall(session: FirSession, @Suppress("UNUSED_PARAMETER") kind: FirConstKind<T>): FirArrayOfCall {
-    return FirArrayOfCallImpl(null).apply {
+    return buildArrayOfCall {
         for (element in this@createArrayOfCall) {
             arguments += element.createConstant(session)
         }
@@ -306,15 +309,15 @@ private fun <T> List<T>.createArrayOfCall(session: FirSession, @Suppress("UNUSED
 
 internal fun Any?.createConstant(session: FirSession): FirExpression {
     return when (this) {
-        is Byte -> FirConstExpressionImpl(null, FirConstKind.Byte, this)
-        is Short -> FirConstExpressionImpl(null, FirConstKind.Short, this)
-        is Int -> FirConstExpressionImpl(null, FirConstKind.Int, this)
-        is Long -> FirConstExpressionImpl(null, FirConstKind.Long, this)
-        is Char -> FirConstExpressionImpl(null, FirConstKind.Char, this)
-        is Float -> FirConstExpressionImpl(null, FirConstKind.Float, this)
-        is Double -> FirConstExpressionImpl(null, FirConstKind.Double, this)
-        is Boolean -> FirConstExpressionImpl(null, FirConstKind.Boolean, this)
-        is String -> FirConstExpressionImpl(null, FirConstKind.String, this)
+        is Byte -> buildConstExpression(null, FirConstKind.Byte, this)
+        is Short -> buildConstExpression(null, FirConstKind.Short, this)
+        is Int -> buildConstExpression(null, FirConstKind.Int, this)
+        is Long -> buildConstExpression(null, FirConstKind.Long, this)
+        is Char -> buildConstExpression(null, FirConstKind.Char, this)
+        is Float -> buildConstExpression(null, FirConstKind.Float, this)
+        is Double -> buildConstExpression(null, FirConstKind.Double, this)
+        is Boolean -> buildConstExpression(null, FirConstKind.Boolean, this)
+        is String -> buildConstExpression(null, FirConstKind.String, this)
         is ByteArray -> toList().createArrayOfCall(session, FirConstKind.Byte)
         is ShortArray -> toList().createArrayOfCall(session, FirConstKind.Short)
         is IntArray -> toList().createArrayOfCall(session, FirConstKind.Int)
@@ -323,11 +326,11 @@ internal fun Any?.createConstant(session: FirSession): FirExpression {
         is FloatArray -> toList().createArrayOfCall(session, FirConstKind.Float)
         is DoubleArray -> toList().createArrayOfCall(session, FirConstKind.Double)
         is BooleanArray -> toList().createArrayOfCall(session, FirConstKind.Boolean)
-        null -> FirConstExpressionImpl(null, FirConstKind.Null, null)
+        null -> buildConstExpression(null, FirConstKind.Null, null)
 
-        else -> FirErrorExpressionImpl(
-            null, FirSimpleDiagnostic("Unknown value in JavaLiteralAnnotationArgument: $this", DiagnosticKind.Java)
-        )
+        else -> buildErrorExpression {
+            diagnostic = FirSimpleDiagnostic("Unknown value in JavaLiteralAnnotationArgument: $this", DiagnosticKind.Java)
+        }
     }
 }
 
@@ -335,8 +338,8 @@ private fun JavaType.toFirResolvedTypeRef(
     session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
 ): FirResolvedTypeRef {
     if (this is JavaClassifierType) return toFirResolvedTypeRef(session, javaTypeParameterStack)
-    return FirResolvedTypeRefImpl(
-        source = null, type = ConeClassErrorType("Unexpected JavaType: $this")
-    )
+    return buildResolvedTypeRef {
+        type = ConeClassErrorType("Unexpected JavaType: $this")
+    }
 }
 

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt

@@ -8,13 +8,14 @@ package org.jetbrains.kotlin.fir.java.declarations
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.builder.AbstractFirRegularClassBuilder
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
@@ -27,38 +28,31 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.fir.visitors.transformInplace
 import org.jetbrains.kotlin.fir.visitors.transformSingle
 import org.jetbrains.kotlin.name.Name
+import kotlin.properties.Delegates
 
-class FirJavaClass internal constructor(
+@UseExperimental(FirImplementationDetail::class)
+class FirJavaClass @FirImplementationDetail internal constructor(
     override val source: FirSourceElement?,
     override val session: FirSession,
-    override val symbol: FirRegularClassSymbol,
+    override var resolvePhase: FirResolvePhase,
     override val name: Name,
-    visibility: Visibility,
-    modality: Modality?,
+    override val annotations: MutableList<FirAnnotationCall>,
+    override var status: FirDeclarationStatus,
     override val classKind: ClassKind,
-    isTopLevel: Boolean,
-    isStatic: Boolean,
+    override val declarations: MutableList<FirDeclaration>,
     override val scopeProvider: FirScopeProvider,
+    override val symbol: FirRegularClassSymbol,
+    override val superTypeRefs: MutableList<FirTypeRef>,
+    override val typeParameters: MutableList<FirTypeParameter>,
     internal val javaTypeParameterStack: JavaTypeParameterStack,
     internal val existingNestedClassifierNames: List<Name>
 ) : FirPureAbstractElement(), FirRegularClass, FirModifiableClass<FirRegularClass> {
-    override var status: FirDeclarationStatusImpl = FirDeclarationStatusImpl(visibility, modality)
-    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
-    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
+    override val hasLazyNestedClassifiers: Boolean get() = true
 
     init {
         symbol.bind(this)
-        status.isInner = !isTopLevel && !isStatic
-        status.isCompanion = false
-        status.isData = false
-        status.isInline = false
     }
 
-    override var resolvePhase: FirResolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
-
-    override val superTypeRefs = mutableListOf<FirTypeRef>()
-
-    override val declarations = mutableListOf<FirDeclaration>()
 
     override val companionObject: FirRegularClass?
         get() = null
@@ -94,3 +88,74 @@ class FirJavaClass internal constructor(
         return this
     }
 }
+
+@FirBuilderDsl
+internal class FirJavaClassBuilder : AbstractFirRegularClassBuilder, FirAnnotationContainerBuilder {
+    lateinit var visibility: Visibility
+    var modality: Modality? = null
+    var isTopLevel: Boolean by Delegates.notNull()
+    var isStatic: Boolean by Delegates.notNull()
+    var isNotSam: Boolean by Delegates.notNull()
+    lateinit var javaTypeParameterStack: JavaTypeParameterStack
+    val existingNestedClassifierNames: MutableList<Name> = mutableListOf()
+
+    override var source: FirSourceElement? = null
+    override lateinit var session: FirSession
+    override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    override lateinit var name: Name
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
+    override lateinit var status: FirDeclarationStatus
+    override lateinit var classKind: ClassKind
+    override val declarations: MutableList<FirDeclaration> = mutableListOf()
+    override lateinit var scopeProvider: FirScopeProvider
+    override lateinit var symbol: FirRegularClassSymbol
+
+    override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()
+
+    @UseExperimental(FirImplementationDetail::class)
+    override fun build(): FirJavaClass {
+        val status = FirDeclarationStatusImpl(visibility, modality).apply {
+            isInner = !isTopLevel && !isStatic
+            isCompanion = false
+            isData = false
+            isInline = false
+            isNotSAM = this@FirJavaClassBuilder.isNotSam
+        }
+
+        return FirJavaClass(
+            source,
+            session,
+            resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES,
+            name,
+            annotations,
+            status,
+            classKind,
+            declarations,
+            scopeProvider,
+            symbol,
+            superTypeRefs,
+            typeParameters,
+            javaTypeParameterStack,
+            existingNestedClassifierNames
+        )
+    }
+
+    @Deprecated("Modification of 'hasLazyNestedClassifiers' has no impact for FirClassImplBuilder", level = DeprecationLevel.HIDDEN)
+    override var companionObject: FirRegularClass?
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+
+    @Deprecated("Modification of 'hasLazyNestedClassifiers' has no impact for FirClassImplBuilder", level = DeprecationLevel.HIDDEN)
+    override var hasLazyNestedClassifiers: Boolean
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+}
+
+internal inline fun buildJavaClass(init: FirJavaClassBuilder.() -> Unit): FirJavaClass {
+    return FirJavaClassBuilder().apply(init).build()
+}

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt

@@ -7,16 +7,14 @@ package org.jetbrains.kotlin.fir.java.declarations
 
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.CONSTRUCTOR_NAME
-import org.jetbrains.kotlin.fir.FirPureAbstractElement
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.builder.FirConstructorBuilder
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.references.impl.FirEmptyControlFlowGraphReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
@@ -25,30 +23,23 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.fir.visitors.transformInplace
 import org.jetbrains.kotlin.fir.visitors.transformSingle
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+import kotlin.properties.Delegates
 
-class FirJavaConstructor(
+@UseExperimental(FirImplementationDetail::class)
+class FirJavaConstructor @FirImplementationDetail constructor(
     override val source: FirSourceElement?,
     override val session: FirSession,
     override val symbol: FirConstructorSymbol,
-    visibility: Visibility,
     override val isPrimary: Boolean,
-    isInner: Boolean,
-    override var returnTypeRef : FirTypeRef
-) : FirPureAbstractElement(), FirAbstractAnnotatedElement, FirConstructor {
+    override var returnTypeRef: FirTypeRef,
+    override val valueParameters: MutableList<FirValueParameter>,
+    override val typeParameters: MutableList<FirTypeParameter>,
+    override val annotations: MutableList<FirAnnotationCall>,
+    override var status: FirDeclarationStatus,
+    override var resolvePhase: FirResolvePhase,
+) : FirPureAbstractElement(), FirConstructor {
     override val receiverTypeRef: FirTypeRef? get() = null
-    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
-    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
-
-    override var status: FirDeclarationStatus = FirDeclarationStatusImpl(visibility, Modality.FINAL).apply {
-        isExpect = false
-        isActual = false
-        isOverride = false
-        this.isInner = isInner
-    }
-
-    override var resolvePhase: FirResolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
 
     init {
         symbol.bind(this)
@@ -60,9 +51,7 @@ class FirJavaConstructor(
     override val body: FirBlock?
         get() = null
 
-    override val valueParameters = mutableListOf<FirValueParameter>()
-
-    override val controlFlowGraphReference: FirControlFlowGraphReference get() = FirEmptyControlFlowGraphReference()
+    override val controlFlowGraphReference: FirControlFlowGraphReference get() = FirEmptyControlFlowGraphReference
 
     override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirJavaConstructor {
         valueParameters.transformInplace(transformer, data)
@@ -116,10 +105,80 @@ class FirJavaConstructor(
         returnTypeRef = newReturnTypeRef
     }
 
-    override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?) {}
-
     override fun replaceValueParameters(newValueParameters: List<FirValueParameter>) {
         valueParameters.clear()
-        valueParameters.addAll(newValueParameters)
+        valueParameters += newValueParameters
     }
+
+    override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?) {}
 }
+
+@FirBuilderDsl
+class FirJavaConstructorBuilder : FirConstructorBuilder() {
+    lateinit var visibility: Visibility
+    var isInner: Boolean by Delegates.notNull()
+    var isPrimary: Boolean by Delegates.notNull()
+
+    @UseExperimental(FirImplementationDetail::class)
+    override fun build(): FirJavaConstructor {
+        val status = FirDeclarationStatusImpl(visibility, Modality.FINAL).apply {
+            isExpect = false
+            isActual = false
+            isOverride = false
+            isInner = this@FirJavaConstructorBuilder.isInner
+        }
+
+        return FirJavaConstructor(
+            source,
+            session,
+            symbol,
+            isPrimary,
+            returnTypeRef,
+            valueParameters,
+            typeParameters,
+            annotations,
+            status,
+            resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
+        )
+    }
+
+    @Deprecated("Modification of 'body' has no impact for FirJavaConstructorBuilder", level = DeprecationLevel.HIDDEN)
+    override var body: FirBlock?
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+
+    @Deprecated("Modification of 'delegatedConstructor' has no impact for FirJavaConstructorBuilder", level = DeprecationLevel.HIDDEN)
+    override var delegatedConstructor: FirDelegatedConstructorCall?
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+
+    @Deprecated("Modification of 'resolvePhase' has no impact for FirJavaConstructorBuilder", level = DeprecationLevel.HIDDEN)
+    override var resolvePhase: FirResolvePhase
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+
+    @Deprecated("Modification of 'status' has no impact for FirJavaConstructorBuilder", level = DeprecationLevel.HIDDEN)
+    override var status: FirDeclarationStatus
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+
+    @Deprecated("Modification of 'receiverTypeRef' has no impact for FirJavaConstructorBuilder", level = DeprecationLevel.HIDDEN)
+    override var receiverTypeRef: FirTypeRef?
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+}
+
+inline fun buildJavaConstructor(init: FirJavaConstructorBuilder.() -> Unit): FirJavaConstructor {
+    return FirJavaConstructorBuilder().apply(init).build()
+}
+

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt

@@ -7,13 +7,15 @@ package org.jetbrains.kotlin.fir.java.declarations
 
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.builder.FirFieldBuilder
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -23,35 +25,32 @@ import org.jetbrains.kotlin.fir.visitors.transformInplace
 import org.jetbrains.kotlin.fir.visitors.transformSingle
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+import kotlin.properties.Delegates
 
-class FirJavaField(
+@UseExperimental(FirImplementationDetail::class)
+class FirJavaField @FirImplementationDetail constructor(
     override val source: FirSourceElement?,
     override val session: FirSession,
     override val symbol: FirFieldSymbol,
     override val name: Name,
-    visibility: Visibility,
-    modality: Modality?,
+    override var resolvePhase: FirResolvePhase,
     override var returnTypeRef: FirTypeRef,
+    override var status: FirDeclarationStatus,
     override val isVar: Boolean,
-    isStatic: Boolean
-) : FirAbstractAnnotatedElement, FirField() {
+    override val annotations: MutableList<FirAnnotationCall>,
+    override val typeParameters: MutableList<FirTypeParameter>,
+) : FirField() {
     init {
         symbol.bind(this)
     }
 
-    override var status: FirDeclarationStatus = FirDeclarationStatusImpl(visibility, modality).apply {
-        this.isStatic = isStatic
-        isExpect = false
-        isActual = false
-        isOverride = false
-    }
     override val receiverTypeRef: FirTypeRef? get() = null
-    override var resolvePhase: FirResolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
-    override val isVal: Boolean = true
+    override val isVal: Boolean get() = !isVar
     override val getter: FirPropertyAccessor? get() = null
     override val setter: FirPropertyAccessor? get() = null
-    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
-    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
 
     override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirField {
         returnTypeRef = returnTypeRef.transformSingle(transformer, data)
@@ -118,3 +117,43 @@ class FirJavaField(
 
     override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?) {}
 }
+
+@FirBuilderDsl
+internal class FirJavaFieldBuilder : FirFieldBuilder() {
+    var modality: Modality? = null
+    lateinit var visibility: Visibility
+    var isStatic: Boolean by Delegates.notNull()
+
+    override var resolvePhase: FirResolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
+
+    @UseExperimental(FirImplementationDetail::class)
+    override fun build(): FirJavaField {
+        val status: FirDeclarationStatus = FirDeclarationStatusImpl(visibility, modality).apply {
+            isStatic = this@FirJavaFieldBuilder.isStatic
+            isExpect = false
+            isActual = false
+            isOverride = false
+        }
+
+        return FirJavaField(
+            source,
+            session,
+            symbol as FirFieldSymbol,
+            name,
+            resolvePhase,
+            returnTypeRef,
+            status,
+            isVar,
+            annotations,
+            typeParameters
+        )
+    }
+}
+
+@UseExperimental(ExperimentalContracts::class)
+internal inline fun buildJavaField(init: FirJavaFieldBuilder.() -> Unit): FirJavaField {
+    contract {
+        callsInPlace(init, InvocationKind.EXACTLY_ONCE)
+    }
+    return FirJavaFieldBuilder().apply(init).build()
+}

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt

@@ -7,45 +7,94 @@ package org.jetbrains.kotlin.fir.java.declarations
 
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.builder.FirSimpleFunctionBuilder
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
-import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+import kotlin.properties.Delegates
 
-class FirJavaMethod(
-    session: FirSession,
+@UseExperimental(FirImplementationDetail::class)
+class FirJavaMethod @FirImplementationDetail constructor(
     source: FirSourceElement?,
-    symbol: FirNamedFunctionSymbol,
+    session: FirSession,
+    resolvePhase: FirResolvePhase,
+    returnTypeRef: FirTypeRef,
+    receiverTypeRef: FirTypeRef?,
+    typeParameters: MutableList<FirTypeParameter>,
+    valueParameters: MutableList<FirValueParameter>,
+    body: FirBlock?,
     name: Name,
-    visibility: Visibility,
-    modality: Modality?,
-    returnTypeRef: FirJavaTypeRef,
-    isStatic: Boolean
+    status: FirDeclarationStatus,
+    containerSource: DeserializedContainerSource?,
+    symbol: FirFunctionSymbol<FirSimpleFunction>,
+    annotations: MutableList<FirAnnotationCall>,
 ) : FirSimpleFunctionImpl(
     source,
     session,
+    resolvePhase,
     returnTypeRef,
-    null,
-    FirDeclarationStatusImpl(visibility, modality).apply {
-        this.isStatic = isStatic
-        isExpect = false
-        isActual = false
-        isOverride = false
-        isOperator = true // All Java methods with name that allows to use it in operator form are considered operators
-        isInfix = false
-        isInline = false
-        isTailRec = false
-        isExternal = false
-        isSuspend = false
-    },
+    receiverTypeRef,
+    typeParameters,
+    valueParameters,
+    body,
+    status,
+    containerSource,
     name,
-    symbol
-) {
-    init {
-        resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
+    symbol,
+    annotations,
+)
+
+@FirBuilderDsl
+class FirJavaMethodBuilder : FirSimpleFunctionBuilder() {
+    lateinit var visibility: Visibility
+    var modality: Modality? = null
+    var isStatic: Boolean by Delegates.notNull()
+    override var resolvePhase: FirResolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
+
+    @UseExperimental(FirImplementationDetail::class)
+    override fun build(): FirJavaMethod {
+        val status = FirDeclarationStatusImpl(visibility, modality).apply {
+            isStatic = this@FirJavaMethodBuilder.isStatic
+            isExpect = false
+            isActual = false
+            isOverride = false
+            isOperator = true // All Java methods with name that allows to use it in operator form are considered operators
+            isInfix = false
+            isInline = false
+            isTailRec = false
+            isExternal = false
+            isSuspend = false
+        }
+
+        return FirJavaMethod(
+            source,
+            session,
+            resolvePhase,
+            returnTypeRef as FirJavaTypeRef,
+            receiverTypeRef = null,
+            typeParameters,
+            valueParameters,
+            body,
+            name,
+            status,
+            containerSource,
+            symbol,
+            annotations,
+        )
     }
 }
+
+inline fun buildJavaMethod(init: FirJavaMethodBuilder.() -> Unit): FirJavaMethod {
+    return FirJavaMethodBuilder().apply(init).build()
+}

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaValueParameter.kt

@@ -5,32 +5,103 @@
 
 package org.jetbrains.kotlin.fir.java.declarations
 
+import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.builder.FirValueParameterBuilder
 import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
-import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 
-class FirJavaValueParameter(
-    session: FirSession,
+@UseExperimental(FirImplementationDetail::class)
+class FirJavaValueParameter @FirImplementationDetail constructor(
     source: FirSourceElement?,
+    session: FirSession,
+    resolvePhase: FirResolvePhase,
+    returnTypeRef: FirTypeRef,
     name: Name,
-    returnTypeRef: FirJavaTypeRef,
-    isVararg: Boolean
+    symbol: FirVariableSymbol<FirValueParameter>,
+    annotations: MutableList<FirAnnotationCall>,
+    defaultValue: FirExpression?,
+    isCrossinline: Boolean,
+    isNoinline: Boolean,
+    isVararg: Boolean,
 ) : FirValueParameterImpl(
     source,
     session,
+    resolvePhase,
     returnTypeRef,
     name,
-    FirVariableSymbol(name),
-    defaultValue = null,
-    isCrossinline = false,
-    isNoinline = false,
-    isVararg = isVararg
-) {
-    init {
-        resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
+    symbol,
+    annotations,
+    defaultValue,
+    isCrossinline,
+    isNoinline,
+    isVararg,
+)
+
+@FirBuilderDsl
+class FirJavaValueParameterBuilder : FirValueParameterBuilder() {
+    @UseExperimental(FirImplementationDetail::class)
+    override fun build(): FirJavaValueParameter {
+        return FirJavaValueParameter(
+            source,
+            session,
+            resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES,
+            returnTypeRef,
+            name,
+            symbol = FirVariableSymbol(name),
+            annotations,
+            defaultValue = null,
+            isCrossinline = false,
+            isNoinline = false,
+            isVararg,
+        )
     }
+
+    @Deprecated("Modification of 'resolvePhase' has no impact for FirJavaValueParameterBuilder", level = DeprecationLevel.HIDDEN)
+    override var resolvePhase: FirResolvePhase
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+
+    @Deprecated("Modification of '' has no impact for FirJavaValueParameterBuilder", level = DeprecationLevel.HIDDEN)
+    override var symbol: FirVariableSymbol<FirValueParameter>
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+
+    @Deprecated("Modification of 'defaultValue' has no impact for FirJavaValueParameterBuilder", level = DeprecationLevel.HIDDEN)
+    override var defaultValue: FirExpression?
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+
+    @Deprecated("Modification of 'isCrossinline' has no impact for FirJavaValueParameterBuilder", level = DeprecationLevel.HIDDEN)
+    override var isCrossinline: Boolean
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+
+    @Deprecated("Modification of 'isNoinline' has no impact for FirJavaValueParameterBuilder", level = DeprecationLevel.HIDDEN)
+    override var isNoinline: Boolean
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+
 }
+
+inline fun buildJavaValueParameter(init: FirJavaValueParameterBuilder.() -> Unit): FirJavaValueParameter {
+    return FirJavaValueParameterBuilder().apply(init).build()
+}

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt

@@ -9,9 +9,11 @@ import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirPropertyImpl
 import org.jetbrains.kotlin.fir.deserialization.FirDeserializationContext
 import org.jetbrains.kotlin.fir.deserialization.deserializeClassToSymbol
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
@@ -19,21 +21,20 @@ import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.impl.*
-import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
 import org.jetbrains.kotlin.fir.java.createConstant
 import org.jetbrains.kotlin.fir.java.topLevelName
-import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
+import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
+import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.kotlin.*
@@ -61,7 +62,7 @@ class KotlinDeserializedJvmSymbolsProvider(
     private val javaSymbolProvider: JavaSymbolProvider,
     private val kotlinClassFinder: KotlinClassFinder,
     private val javaClassFinder: JavaClassFinder,
-    private val kotlinScopeProvider: KotlinScopeProvider
+    private val kotlinScopeProvider: KotlinScopeProvider,
 ) : AbstractFirSymbolProvider<FirClassLikeSymbol<*>>() {
     private val classesCache = HashMap<ClassId, FirRegularClassSymbol>()
     private val typeAliasCache = HashMap<ClassId, FirTypeAliasSymbol?>()
@@ -72,7 +73,7 @@ class KotlinDeserializedJvmSymbolsProvider(
     private class PackagePartsCacheData(
         val proto: ProtoBuf.Package,
         val context: FirDeserializationContext,
-        val source: JvmPackagePartSource
+        val source: JvmPackagePartSource,
     ) {
         val topLevelFunctionNameIndex by lazy {
             proto.functionList.withIndex()
@@ -113,16 +114,16 @@ class KotlinDeserializedJvmSymbolsProvider(
 
             val source = JvmPackagePartSource(
                 kotlinJvmBinaryClass, packageProto, nameResolver,
-                kotlinJvmBinaryClass.incompatibility, kotlinJvmBinaryClass.isPreReleaseInvisible
+                kotlinJvmBinaryClass.incompatibility, kotlinJvmBinaryClass.isPreReleaseInvisible,
             )
 
             PackagePartsCacheData(
                 packageProto,
                 FirDeserializationContext.createForPackage(
                     packageFqName, packageProto, nameResolver, session,
-                    JvmBinaryAnnotationDeserializer(session)
+                    JvmBinaryAnnotationDeserializer(session),
                 ),
-                source
+                source,
             )
         }
     }
@@ -142,7 +143,7 @@ class KotlinDeserializedJvmSymbolsProvider(
     }
 
     private fun findAndDeserializeTypeAlias(
-        classId: ClassId
+        classId: ClassId,
     ): FirTypeAliasSymbol? {
         if (!classId.relativeClassName.isOneSegmentFQN()) return null
         return typeAliasCache.getOrPutNullable(classId) {
@@ -164,15 +165,15 @@ class KotlinDeserializedJvmSymbolsProvider(
 
     private fun FirClassifierSymbol<*>?.toDefaultResolvedTypeRef(classId: ClassId): FirResolvedTypeRef {
         return this?.let {
-            FirResolvedTypeRefImpl(
-                null, it.constructType(emptyList(), isNullable = false)
-            )
-        } ?: FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Symbol not found for $classId", DiagnosticKind.Java))
+            buildResolvedTypeRef {
+                type = it.constructType(emptyList(), isNullable = false)
+            }
+        } ?: buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Symbol not found for $classId", DiagnosticKind.Java) }
 
     }
 
     private fun loadAnnotation(
-        annotationClassId: ClassId, result: MutableList<FirAnnotationCall>
+        annotationClassId: ClassId, result: MutableList<FirAnnotationCall>,
     ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
         val lookupTag = ConeClassLikeLookupTagImpl(annotationClassId)
         val symbol = lookupTag.toSymbol(session)
@@ -189,39 +190,39 @@ class KotlinDeserializedJvmSymbolsProvider(
             private fun ClassLiteralValue.toFirClassReferenceExpression(): FirClassReferenceExpression {
                 val literalLookupTag = ConeClassLikeLookupTagImpl(classId)
                 val literalSymbol = literalLookupTag.toSymbol(this@KotlinDeserializedJvmSymbolsProvider.session)
-                return FirClassReferenceExpressionImpl(
-                    null,
-                    literalSymbol.toDefaultResolvedTypeRef(classId)
-                )
+                return buildClassReferenceExpression {
+                    classTypeRef = literalSymbol.toDefaultResolvedTypeRef(classId)
+                }
             }
 
             private fun ClassId.toEnumEntryReferenceExpression(name: Name): FirExpression {
-                return FirFunctionCallImpl(null).apply {
+                return buildFunctionCall {
                     val entryCallableSymbol =
                         this@KotlinDeserializedJvmSymbolsProvider.session.firSymbolProvider.getClassDeclaredCallableSymbols(
-                            this@toEnumEntryReferenceExpression, name
+                            this@toEnumEntryReferenceExpression, name,
                         ).firstOrNull()
 
-                    this.calleeReference = when {
+                    calleeReference = when {
                         entryCallableSymbol != null -> {
-                            FirResolvedNamedReferenceImpl(
-                                null, name, entryCallableSymbol
-                            )
+                            buildResolvedNamedReference {
+                                this.name = name
+                                resolvedSymbol = entryCallableSymbol
+                            }
                         }
                         else -> {
-                            FirErrorNamedReferenceImpl(
-                                null,
-                                FirSimpleDiagnostic(
-                                    "Strange deserialized enum value: ${this@toEnumEntryReferenceExpression}.$name", DiagnosticKind.Java
+                            buildErrorNamedReference {
+                                diagnostic = FirSimpleDiagnostic(
+                                    "Strange deserialized enum value: ${this@toEnumEntryReferenceExpression}.$name",
+                                    DiagnosticKind.Java,
                                 )
-                            )
+                            }
                         }
                     }
                 }
             }
 
             override fun visitClassLiteral(name: Name, value: ClassLiteralValue) {
-                argumentMap[name] = FirGetClassCallImpl(null).apply {
+                argumentMap[name] = buildGetClassCall {
                     arguments += value.toFirClassReferenceExpression()
                 }
             }
@@ -247,7 +248,7 @@ class KotlinDeserializedJvmSymbolsProvider(
                     }
 
                     override fun visitEnd() {
-                        argumentMap[name] = FirArrayOfCallImpl(null).apply {
+                        argumentMap[name] = buildArrayOfCall {
                             arguments += elements
                         }
                     }
@@ -266,11 +267,14 @@ class KotlinDeserializedJvmSymbolsProvider(
             }
 
             override fun visitEnd() {
-                result += FirAnnotationCallImpl(null, null, symbol.toDefaultResolvedTypeRef(annotationClassId)).apply {
+                result += buildAnnotationCall {
+                    annotationTypeRef = symbol.toDefaultResolvedTypeRef(annotationClassId)
                     for ((name, expression) in argumentMap) {
-                        arguments += FirNamedArgumentExpressionImpl(
-                            null, expression, false, name
-                        )
+                        arguments += buildNamedArgumentExpression {
+                            this.expression = expression
+                            this.name = name
+                            isSpread = false
+                        }
                     }
                 }
             }
@@ -282,7 +286,7 @@ class KotlinDeserializedJvmSymbolsProvider(
     }
 
     private fun loadAnnotationIfNotSpecial(
-        annotationClassId: ClassId, result: MutableList<FirAnnotationCall>
+        annotationClassId: ClassId, result: MutableList<FirAnnotationCall>,
     ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
         if (annotationClassId in AbstractBinaryClassAnnotationAndConstantLoader.SPECIAL_ANNOTATIONS) return null
         return loadAnnotation(annotationClassId, result)
@@ -290,7 +294,7 @@ class KotlinDeserializedJvmSymbolsProvider(
 
     private fun findAndDeserializeClass(
         classId: ClassId,
-        parentContext: FirDeserializationContext? = null
+        parentContext: FirDeserializationContext? = null,
     ): FirRegularClassSymbol? {
         if (hasNoTopLevelClassOf(classId)) return null
         if (classesCache.containsKey(classId)) return classesCache[classId]
@@ -326,34 +330,35 @@ class KotlinDeserializedJvmSymbolsProvider(
                 classId, classProto, symbol, nameResolver, session,
                 JvmBinaryAnnotationDeserializer(session),
                 kotlinScopeProvider,
-                parentContext, this::findAndDeserializeClass
+                parentContext, this::findAndDeserializeClass,
             )
 
             classesCache[classId] = symbol
             val annotations = mutableListOf<FirAnnotationCall>()
-            kotlinJvmBinaryClass.loadClassAnnotations(object : KotlinJvmBinaryClass.AnnotationVisitor {
-                override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
-                    return loadAnnotationIfNotSpecial(classId, annotations)
-                }
+            kotlinJvmBinaryClass.loadClassAnnotations(
+                object : KotlinJvmBinaryClass.AnnotationVisitor {
+                    override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
+                        return loadAnnotationIfNotSpecial(classId, annotations)
+                    }
 
-                override fun visitEnd() {
-                }
+                    override fun visitEnd() {
+                    }
 
 
-            }, null)
-            (symbol.fir as FirAbstractAnnotatedElement).annotations += annotations
+                },
+                null,
+            )
+            (symbol.fir.annotations as MutableList<FirAnnotationCall>) += annotations
         }
 
         return classesCache[classId]
-//        }
     }
 
     private fun loadFunctionsByName(part: PackagePartsCacheData, name: Name): List<FirCallableSymbol<*>> {
         val functionIds = part.topLevelFunctionNameIndex[name] ?: return emptyList()
         return functionIds.map { part.proto.getFunction(it) }
             .map {
-                val firNamedFunction = part.context.memberDeserializer.loadFunction(it) as FirSimpleFunctionImpl
-                firNamedFunction.containerSource = part.source
+                val firNamedFunction = part.context.memberDeserializer.loadFunction(it, containerSource = part.source) as FirSimpleFunctionImpl
                 firNamedFunction.symbol
             }
     }
@@ -362,8 +367,7 @@ class KotlinDeserializedJvmSymbolsProvider(
         val propertyIds = part.topLevelPropertyNameIndex[name] ?: return emptyList()
         return propertyIds.map { part.proto.getProperty(it) }
             .map {
-                val firProperty = part.context.memberDeserializer.loadProperty(it) as FirPropertyImpl
-                firProperty.containerSource = part.source
+                val firProperty = part.context.memberDeserializer.loadProperty(it, containerSource = part.source)
                 firProperty.symbol
             }
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt

@@ -11,14 +11,14 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirQualifiedAccessExpressionImpl
+import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
 import org.jetbrains.kotlin.fir.java.toConeProjection
 import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
+import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.firUnsafe
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.DEFAULT_NULL_FQ_NAME
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.DEFAULT_VALUE_FQ_NAME
@@ -111,7 +111,8 @@ private fun JavaType?.enhancePossiblyFlexible(
         }
     }
 
-    return FirResolvedTypeRefImpl(source = null, type = enhanced).apply {
+    return buildResolvedTypeRef {
+        this.type = enhanced
         this.annotations += annotations
     }
 }
@@ -361,19 +362,21 @@ internal fun ConeKotlinType.lexicalCastFrom(session: FirSession, value: String):
         val name = Name.identifier(value)
         val firEnumEntry = firElement.collectEnumEntries().find { it.name == name }
 
-        return if (firEnumEntry != null) FirQualifiedAccessExpressionImpl(null).apply {
-            calleeReference = FirResolvedNamedReferenceImpl(
-                null, name, firEnumEntry.symbol
-            )
+        return if (firEnumEntry != null) buildQualifiedAccessExpression {
+            calleeReference = buildResolvedNamedReference {
+                this.name = name
+                resolvedSymbol = firEnumEntry.symbol
+            }
         } else if (firElement is FirJavaClass) {
             val firStaticProperty = firElement.declarations.filterIsInstance<FirJavaField>().find {
                 it.isStatic && it.modality == Modality.FINAL && it.name == name
             }
             if (firStaticProperty != null) {
-                FirQualifiedAccessExpressionImpl(null).apply {
-                    calleeReference = FirResolvedNamedReferenceImpl(
-                        null, name, firStaticProperty.symbol as FirCallableSymbol<*>
-                    )
+                buildQualifiedAccessExpression {
+                    calleeReference = buildResolvedNamedReference {
+                        this.name = name
+                        resolvedSymbol = firStaticProperty.symbol as FirCallableSymbol<*>
+                    }
                 }
             } else null
         } else null
@@ -385,15 +388,15 @@ internal fun ConeKotlinType.lexicalCastFrom(session: FirSession, value: String):
 
     val (number, radix) = extractRadix(value)
     return when (classId.relativeClassName.asString()) {
-        "Boolean" -> FirConstExpressionImpl(null, FirConstKind.Boolean, value.toBoolean())
-        "Char" -> FirConstExpressionImpl(null, FirConstKind.Char, value.singleOrNull() ?: return null)
-        "Byte" -> FirConstExpressionImpl(null, FirConstKind.Byte, number.toByteOrNull(radix) ?: return null)
-        "Short" -> FirConstExpressionImpl(null, FirConstKind.Short, number.toShortOrNull(radix) ?: return null)
-        "Int" -> FirConstExpressionImpl(null, FirConstKind.Int, number.toIntOrNull(radix) ?: return null)
-        "Long" -> FirConstExpressionImpl(null, FirConstKind.Long, number.toLongOrNull(radix) ?: return null)
-        "Float" -> FirConstExpressionImpl(null, FirConstKind.Float, value.toFloatOrNull() ?: return null)
-        "Double" -> FirConstExpressionImpl(null, FirConstKind.Double, value.toDoubleOrNull() ?: return null)
-        "String" -> FirConstExpressionImpl(null, FirConstKind.String, value)
+        "Boolean" -> buildConstExpression(null, FirConstKind.Boolean, value.toBoolean())
+        "Char" -> buildConstExpression(null, FirConstKind.Char, value.singleOrNull() ?: return null)
+        "Byte" -> buildConstExpression(null, FirConstKind.Byte, number.toByteOrNull(radix) ?: return null)
+        "Short" -> buildConstExpression(null, FirConstKind.Short, number.toShortOrNull(radix) ?: return null)
+        "Int" -> buildConstExpression(null, FirConstKind.Int, number.toIntOrNull(radix) ?: return null)
+        "Long" -> buildConstExpression(null, FirConstKind.Long, number.toLongOrNull(radix) ?: return null)
+        "Float" -> buildConstExpression(null, FirConstKind.Float, value.toFloatOrNull() ?: return null)
+        "Double" -> buildConstExpression(null, FirConstKind.Double, value.toDoubleOrNull() ?: return null)
+        "String" -> buildConstExpression(null, FirConstKind.String, value)
         else -> null
     }
 }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt

@@ -9,14 +9,17 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.*
+import org.jetbrains.kotlin.fir.declarations.builder.FirConstructorBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.FirPrimaryConstructorBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.FirSimpleFunctionBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirConstKind
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl
+import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
 import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.java.declarations.*
 import org.jetbrains.kotlin.fir.java.enhancement.*
-import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.jvm.computeJvmDescriptor
@@ -24,6 +27,7 @@ import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
 import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver
 import org.jetbrains.kotlin.load.java.descriptors.NullDefaultValue
 import org.jetbrains.kotlin.load.java.descriptors.StringDefaultValue
@@ -86,20 +90,17 @@ class JavaClassEnhancementScope(
                 val newReturnTypeRef = enhanceReturnType(firElement, emptyList(), memberContext, null)
 
                 val symbol = FirFieldSymbol(original.callableId)
-                with(firElement) {
-                    FirJavaField(
-                        firElement.source,
-                        this@JavaClassEnhancementScope.session,
-                        symbol,
-                        name,
-                        visibility,
-                        modality,
-                        newReturnTypeRef,
-                        isVar,
-                        isStatic
-                    ).apply {
-                        annotations += firElement.annotations
-                    }
+                buildJavaField {
+                    source = firElement.source
+                    session = this@JavaClassEnhancementScope.session
+                    this.symbol = symbol
+                    this.name = name
+                    visibility = firElement.visibility
+                    modality = firElement.modality
+                    returnTypeRef = newReturnTypeRef
+                    isVar = firElement.isVar
+                    isStatic = firElement.isStatic
+                    annotations += firElement.annotations
                 }
                 return symbol
             }
@@ -173,67 +174,68 @@ class JavaClassEnhancementScope(
 
         val newValueParameters = firMethod.valueParameters.zip(newValueParameterInfo) { valueParameter, newInfo ->
             val (newTypeRef, newDefaultValue) = newInfo
-            with(valueParameter) {
-                FirValueParameterImpl(
-                    source, this@JavaClassEnhancementScope.session,
-                    newTypeRef, this.name,
-                    FirVariableSymbol(this.name),
-                    defaultValue ?: newDefaultValue, isCrossinline, isNoinline, isVararg
-                ).apply {
-                    resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
-                    annotations += valueParameter.annotations
-                }
+            buildValueParameter {
+                source = valueParameter.source
+                session = this@JavaClassEnhancementScope.session
+                returnTypeRef = newTypeRef
+                this.name = valueParameter.name
+                symbol = FirVariableSymbol(this.name)
+                defaultValue = valueParameter.defaultValue ?: newDefaultValue
+                isCrossinline = valueParameter.isCrossinline
+                isNoinline = valueParameter.isNoinline
+                isVararg = valueParameter.isVararg
+                resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
+                annotations += valueParameter.annotations
             }
         }
         val function = when (firMethod) {
             is FirJavaConstructor -> {
                 val symbol = FirConstructorSymbol(methodId)
-                val status = FirDeclarationStatusImpl(firMethod.visibility, Modality.FINAL).apply {
-                    isExpect = false
-                    isActual = false
-                    isInner = firMethod.isInner
-                }
                 if (firMethod.isPrimary) {
-                    FirPrimaryConstructorImpl(
-                        firMethod.source,
-                        this@JavaClassEnhancementScope.session,
-                        newReturnTypeRef,
-                        null,
-                        status,
-                        symbol
-                    )
+                    FirPrimaryConstructorBuilder().apply {
+                        source = firMethod.source
+                        session = this@JavaClassEnhancementScope.session
+                        returnTypeRef = newReturnTypeRef
+                        status = FirDeclarationStatusImpl(firMethod.visibility, Modality.FINAL).apply {
+                            isExpect = false
+                            isActual = false
+                            isInner = firMethod.isInner
+                        }
+                        this.symbol = symbol
+                    }
                 } else {
-                    FirConstructorImpl(
-                        firMethod.source,
-                        this@JavaClassEnhancementScope.session,
-                        newReturnTypeRef,
-                        newReceiverTypeRef,
-                        firMethod.status,
-                        symbol
-                    )
+                    FirConstructorBuilder().apply {
+                        source = firMethod.source
+                        session = this@JavaClassEnhancementScope.session
+                        returnTypeRef = newReturnTypeRef
+                        status = firMethod.status
+                        this.symbol = symbol
+                    }
                 }.apply {
                     resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
                     this.valueParameters += newValueParameters
                     this.typeParameters += firMethod.typeParameters
                 }
             }
-            is FirJavaMethod -> FirSimpleFunctionImpl(
-                firMethod.source,
-                this@JavaClassEnhancementScope.session,
-                newReturnTypeRef,
-                newReceiverTypeRef,
-                firMethod.status,
-                name,
-                if (!isAccessor) FirNamedFunctionSymbol(methodId)
-                else FirAccessorSymbol(callableId = propertyId!!, accessorId = methodId)
-            ).apply {
-                resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
-                this.valueParameters += newValueParameters
-                this.typeParameters += firMethod.typeParameters
+            is FirJavaMethod -> {
+                FirSimpleFunctionBuilder().apply {
+                    source = firMethod.source
+                    session = this@JavaClassEnhancementScope.session
+                    returnTypeRef = newReturnTypeRef
+                    receiverTypeRef = newReceiverTypeRef
+                    this.name = name
+                    status = firMethod.status
+                    symbol = if (!isAccessor) FirNamedFunctionSymbol(methodId)
+                    else FirAccessorSymbol(callableId = propertyId!!, accessorId = methodId)
+                    resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
+                    valueParameters += newValueParameters
+                    typeParameters += firMethod.typeParameters
+                }
             }
             else -> throw AssertionError("Unknown Java method to enhance: ${firMethod.render()}")
-        }
-        function.annotations += firMethod.annotations
+        }.apply {
+            annotations += firMethod.annotations
+        }.build()
         return function.symbol
     }
 
@@ -275,7 +277,7 @@ class JavaClassEnhancementScope(
         ).enhance(session, jsr305State, predefinedEnhancementInfo?.parametersInfo?.getOrNull(index))
         val firResolvedTypeRef = signatureParts.type
         val defaultValueExpression = when (val defaultValue = ownerParameter.getDefaultValueFromAnnotation()) {
-            NullDefaultValue -> FirConstExpressionImpl(null, FirConstKind.Null, null)
+            NullDefaultValue -> buildConstExpression(null, FirConstKind.Null, null)
             is StringDefaultValue -> firResolvedTypeRef.type.lexicalCastFrom(session, defaultValue.value)
             null -> null
         }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt

@@ -7,13 +7,11 @@ package org.jetbrains.kotlin.fir.java.scopes
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
+import org.jetbrains.kotlin.fir.declarations.builder.FirSimpleFunctionBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.FirValueParameterBuilder
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaValueParameter
+import org.jetbrains.kotlin.fir.java.declarations.*
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticPropertiesScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.AbstractFirUseSiteMemberScope
@@ -119,29 +117,29 @@ class JavaClassUseSiteMemberScope(
         }
     }
 
-    override fun createFunctionCopy(firSimpleFunction: FirSimpleFunction, newSymbol: FirNamedFunctionSymbol): FirSimpleFunctionImpl {
+    override fun createFunctionCopy(firSimpleFunction: FirSimpleFunction, newSymbol: FirNamedFunctionSymbol): FirSimpleFunctionBuilder {
         if (firSimpleFunction !is FirJavaMethod) return super.createFunctionCopy(firSimpleFunction, newSymbol)
-        return FirJavaMethod(
-            firSimpleFunction.session,
-            firSimpleFunction.source,
-            newSymbol,
-            firSimpleFunction.name,
-            firSimpleFunction.visibility,
-            firSimpleFunction.modality,
-            firSimpleFunction.returnTypeRef as FirJavaTypeRef,
-            firSimpleFunction.status.isStatic
-        )
+        return FirJavaMethodBuilder().apply {
+            session = firSimpleFunction.session
+            source = firSimpleFunction.source
+            symbol = newSymbol
+            name = firSimpleFunction.name
+            visibility = firSimpleFunction.visibility
+            modality = firSimpleFunction.modality
+            returnTypeRef = firSimpleFunction.returnTypeRef
+            isStatic = firSimpleFunction.status.isStatic
+        }
     }
 
-    override fun createValueParameterCopy(parameter: FirValueParameter, newDefaultValue: FirExpression?): FirValueParameterImpl {
+    override fun createValueParameterCopy(parameter: FirValueParameter, newDefaultValue: FirExpression?): FirValueParameterBuilder {
         if (parameter !is FirJavaValueParameter) return super.createValueParameterCopy(parameter, newDefaultValue)
-        return FirJavaValueParameter(
-            parameter.session,
-            parameter.source,
-            parameter.name,
-            parameter.returnTypeRef as FirJavaTypeRef,
-            parameter.isVararg
-        )
+        return FirJavaValueParameterBuilder().apply {
+            session = parameter.session
+            source = parameter.source
+            name = parameter.name
+            returnTypeRef = parameter.returnTypeRef as FirJavaTypeRef
+            isVararg = parameter.isVararg
+        }
     }
 
     override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {

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

@@ -67,6 +67,8 @@ class LightTree2Fir(
         val lightTree = buildLightTree(code)
 
         return DeclarationsConverter(session, scopeProvider, stubMode, lightTree)
-            .convertFile(lightTree.root, fileName)
+            .convertFile(lightTree.root, fileName).also {
+                it
+            }
     }
 }

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

@@ -10,22 +10,30 @@ import com.intellij.openapi.util.Ref
 import com.intellij.psi.tree.IElementType
 import com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.KtNodeTypes
+import org.jetbrains.kotlin.fir.FirLightSourceElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.BaseFirBuilder
 import org.jetbrains.kotlin.fir.builder.Context
 import org.jetbrains.kotlin.fir.builder.escapedStringToCharacter
-import org.jetbrains.kotlin.fir.types.impl.*
+import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
 import org.jetbrains.kotlin.lexer.KtToken
-import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.name.Name
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
 
 open class BaseConverter(
-    session: FirSession,
+    baseSession: FirSession,
     private val tree: FlyweightCapableTreeStructure<LighterASTNode>,
-    context: Context = Context()
-) : BaseFirBuilder<LighterASTNode>(session, context) {
-    protected val implicitType = FirImplicitTypeRefImpl(null)
+    context: Context<LighterASTNode> = Context()
+) : BaseFirBuilder<LighterASTNode>(baseSession, context) {
+    protected val implicitType = buildImplicitTypeRef()
+
+    override fun LighterASTNode.toFirSourceElement(): FirSourceElement {
+        return FirLightSourceElement(this)
+    }
 
     override val LighterASTNode.elementType: IElementType
         get() = this.tokenType
@@ -98,6 +106,7 @@ open class BaseConverter(
         return kidsRef.get()
     }
 
+    @UseExperimental(ExperimentalContracts::class)
     protected inline fun LighterASTNode.forEachChildren(vararg skipTokens: KtToken, f: (LighterASTNode) -> Unit) {
         val kidsArray = this.getChildrenAsArray()
         for (kid in kidsArray) {

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

@@ -14,22 +14,18 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.builder.generateResolvedAccessExpression
-import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
 import org.jetbrains.kotlin.fir.declarations.FirVariable
-import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary
+import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParametersOwnerBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.buildProperty
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirPropertyImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.impl.FirBlockImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList
-import org.jetbrains.kotlin.fir.expressions.impl.FirComponentCallImpl
+import org.jetbrains.kotlin.fir.expressions.builder.FirAnnotationCallBuilder
+import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder
+import org.jetbrains.kotlin.fir.expressions.builder.buildBlock
+import org.jetbrains.kotlin.fir.expressions.builder.buildComponentCall
 import org.jetbrains.kotlin.fir.lightTree.fir.DestructuringDeclaration
 import org.jetbrains.kotlin.fir.lightTree.fir.TypeConstraint
-import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.lexer.KtSingleValueToken
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
@@ -77,22 +73,8 @@ fun LighterASTNode.isExpression(): Boolean {
     }
 }
 
-fun FirTypeParametersOwner.joinTypeParameters(typeConstraints: List<TypeConstraint>) {
-    typeConstraints.forEach { typeConstraint ->
-        this.typeParameters.forEach { typeParameter ->
-            if (typeConstraint.identifier == typeParameter.name.identifier) {
-                (typeParameter as FirTypeParameterImpl).bounds += typeConstraint.firTypeRef
-//                TODO: why this is necessary?
-//                typeParameter.annotations += typeConstraint.firTypeRef.annotations
-                typeParameter.annotations += typeConstraint.annotations
-            }
-            (typeParameter as FirTypeParameterImpl).addDefaultBoundIfNecessary()
-        }
-    }
-}
-
-fun <T : FirCallWithArgumentList> T.extractArgumentsFrom(container: List<FirExpression>, stubMode: Boolean): T {
-    if (!stubMode || this is FirAnnotationCall) {
+fun <T : FirCallBuilder> T.extractArgumentsFrom(container: List<FirExpression>, stubMode: Boolean): T {
+    if (!stubMode || this is FirAnnotationCallBuilder) {
         this.arguments += container
     }
     return this
@@ -125,27 +107,25 @@ fun generateDestructuringBlock(
     container: FirVariable<*>,
     tmpVariable: Boolean
 ): FirExpression {
-    return FirBlockImpl(null).apply {
+    return buildBlock {
         if (tmpVariable) {
             statements += container
         }
         val isVar = multiDeclaration.isVar
         for ((index, entry) in multiDeclaration.entries.withIndex()) {
-            statements += FirPropertyImpl(
-                null,
-                session,
-                entry.returnTypeRef,
-                null,
-                entry.name,
-                FirComponentCallImpl(null, generateResolvedAccessExpression(null, container), index + 1),
-                null,
-                isVar,
-                FirPropertySymbol(entry.name), // TODO?
-                true,
-                FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
-            ).apply {
+            statements += buildProperty {
+                this.session = session
+                returnTypeRef = entry.returnTypeRef
+                name = entry.name
+                initializer = buildComponentCall {
+                    explicitReceiver = generateResolvedAccessExpression(null, container)
+                    componentIndex = index + 1
+                }
+                this.isVar = isVar
+                symbol = FirPropertySymbol(entry.name) // TODO?
+                isLocal = true
+                status = FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
                 annotations += entry.annotations
-                symbol.bind(this)
             }
         }
     }

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

@@ -11,40 +11,36 @@ import com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.KtNodeTypes.*
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirWhenSubject
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.builder.*
 import org.jetbrains.kotlin.fir.declarations.FirVariable
-import org.jetbrains.kotlin.fir.declarations.impl.FirAnonymousFunctionImpl
+import org.jetbrains.kotlin.fir.declarations.builder.buildAnonymousFunction
+import org.jetbrains.kotlin.fir.declarations.builder.buildProperty
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirPropertyImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.*
-import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
-import org.jetbrains.kotlin.fir.impl.FirLabelImpl
+import org.jetbrains.kotlin.fir.expressions.builder.*
+import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
+import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
+import org.jetbrains.kotlin.fir.expressions.impl.buildSingleExpressionBlock
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.jetbrains.kotlin.fir.lightTree.fir.ValueParameter
 import org.jetbrains.kotlin.fir.lightTree.fir.WhenEntry
 import org.jetbrains.kotlin.fir.references.FirNamedReference
-import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirExplicitSuperReference
-import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
-import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
-import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.symbols.CallableId
+import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
+import org.jetbrains.kotlin.fir.references.builder.buildExplicitSuperReference
+import org.jetbrains.kotlin.fir.references.builder.buildExplicitThisReference
+import org.jetbrains.kotlin.fir.references.builder.buildSimpleNamedReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.psi.stubs.elements.KtConstantExpressionElementType
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.util.OperatorNameConventions
@@ -54,11 +50,11 @@ class ExpressionsConverter(
     private val stubMode: Boolean,
     tree: FlyweightCapableTreeStructure<LighterASTNode>,
     private val declarationsConverter: DeclarationsConverter,
-    context: Context = Context()
+    context: Context<LighterASTNode> = Context()
 ) : BaseConverter(session, tree, context) {
 
     inline fun <reified R : FirElement> getAsFirExpression(expression: LighterASTNode?, errorReason: String = ""): R {
-        return expression?.let { convertExpression(it, errorReason) } as? R ?: (FirErrorExpressionImpl(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) as R)
+        return expression?.let { convertExpression(it, errorReason) } as? R ?: (buildErrorExpression(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) as R)
     }
 
     /*****    EXPRESSIONS    *****/
@@ -67,7 +63,7 @@ class ExpressionsConverter(
             return when (expression.tokenType) {
                 LAMBDA_EXPRESSION -> {
                     val lambdaTree = LightTree2Fir.buildLightTreeLambdaExpression(expression.asText)
-                    ExpressionsConverter(session, stubMode, lambdaTree, declarationsConverter, context)
+                    ExpressionsConverter(baseSession, stubMode, lambdaTree, declarationsConverter, context)
                         .convertLambdaExpression(lambdaTree.root)
                 }
                 BINARY_EXPRESSION -> convertBinaryExpression(expression)
@@ -106,11 +102,11 @@ class ExpressionsConverter(
 
                 OBJECT_LITERAL -> declarationsConverter.convertObjectLiteral(expression)
                 FUN -> declarationsConverter.convertFunctionDeclaration(expression)
-                else -> FirErrorExpressionImpl(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax))
+                else -> buildErrorExpression(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax))
             }
         }
 
-        return FirExpressionStub(null)
+        return buildExpressionStub()
     }
 
     /**
@@ -126,27 +122,33 @@ class ExpressionsConverter(
                 BLOCK -> block = it
             }
         }
-
-        return FirAnonymousFunctionImpl(null, session, implicitType, implicitType, FirAnonymousFunctionSymbol(), isLambda = true).apply {
-            context.firFunctions += this
+        
+        val target = FirFunctionTarget(labelName = lambdaExpression.getLabelName(), isLambda = true)
+        return buildAnonymousFunction {
+            source = lambdaExpression.toFirSourceElement()
+            session = baseSession
+            returnTypeRef = implicitType
+            receiverTypeRef = implicitType
+            symbol = FirAnonymousFunctionSymbol()
+            isLambda = true
+            context.firFunctionTargets += target
             var destructuringBlock: FirExpression? = null
             for (valueParameter in valueParameterList) {
                 val multiDeclaration = valueParameter.destructuringDeclaration
                 valueParameters += if (multiDeclaration != null) {
                     val name = Name.special("<destruct>")
-                    val multiParameter = FirValueParameterImpl(
-                        null,
-                        this@ExpressionsConverter.session,
-                        FirImplicitTypeRefImpl(null),
-                        name,
-                        FirVariableSymbol(name),
-                        defaultValue = null,
-                        isCrossinline = false,
-                        isNoinline = false,
+                    val multiParameter = buildValueParameter {
+                        session = baseSession
+                        returnTypeRef = buildImplicitTypeRef()
+                        this.name = name
+                        symbol = FirVariableSymbol(name)
+                        defaultValue = null
+                        isCrossinline = false
+                        isNoinline = false
                         isVararg = false
-                    )
+                    }
                     destructuringBlock = generateDestructuringBlock(
-                        this@ExpressionsConverter.session,
+                        this@ExpressionsConverter.baseSession,
                         multiDeclaration,
                         multiParameter,
                         tmpVariable = false
@@ -157,25 +159,26 @@ class ExpressionsConverter(
                 }
             }
             label = context.firLabels.pop() ?: context.firFunctionCalls.lastOrNull()?.calleeReference?.name?.let {
-                FirLabelImpl(null, it.asString())
+                buildLabel { name = it.asString() }
             }
-            val bodyExpression = block?.let { declarationsConverter.convertBlockExpression(it) }
-                ?: FirErrorExpressionImpl(null, FirSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax))
-            body = if (bodyExpression is FirBlockImpl) {
-                if (bodyExpression.statements.isEmpty()) {
-                    bodyExpression.statements.add(FirUnitExpression(null))
-                }
-                if (destructuringBlock is FirBlock) {
-                    for ((index, statement) in destructuringBlock.statements.withIndex()) {
-                        bodyExpression.statements.add(index, statement)
+            
+            body = if (block != null) {
+                declarationsConverter.convertBlockExpressionWithoutBuilding(block!!).apply {
+                    if (statements.isEmpty()) {
+                        statements.add(buildUnitExpression())
                     }
-                }
-                bodyExpression
+                    if (destructuringBlock is FirBlock) {
+                        for ((index, statement) in destructuringBlock.statements.withIndex()) {
+                            statements.add(index, statement)
+                        }
+                    }
+                }.build()
             } else {
-                FirSingleExpressionBlock(bodyExpression.toReturn())
+                buildSingleExpressionBlock(buildErrorExpression(null, FirSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax)))
             }
-
-            context.firFunctions.removeLast()
+            context.firFunctionTargets.removeLast()
+        }.also { 
+            target.bind(it)
         }
     }
 
@@ -187,7 +190,7 @@ class ExpressionsConverter(
         var isLeftArgument = true
         lateinit var operationTokenName: String
         var leftArgNode: LighterASTNode? = null
-        var rightArgAsFir: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("No right operand", DiagnosticKind.Syntax))
+        var rightArgAsFir: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No right operand", DiagnosticKind.Syntax))
         binaryExpression.forEachChildren {
             when (it.tokenType) {
                 OPERATION_REFERENCE -> {
@@ -208,7 +211,7 @@ class ExpressionsConverter(
         when (operationToken) {
             ELVIS ->
                 return getAsFirExpression<FirExpression>(leftArgNode, "No left operand").generateNotNullOrOther(
-                    session, rightArgAsFir, "elvis", null
+                    baseSession, rightArgAsFir, "elvis", null
                 )
             ANDAND, OROR ->
                 return getAsFirExpression<FirExpression>(leftArgNode, "No left operand").generateLazyLogicalOperation(
@@ -221,10 +224,11 @@ class ExpressionsConverter(
         }
         val conventionCallName = operationToken.toBinaryName()
         return if (conventionCallName != null || operationToken == IDENTIFIER) {
-            FirFunctionCallImpl(null).apply {
-                calleeReference = FirSimpleNamedReference(
-                    null, conventionCallName ?: operationTokenName.nameAsSafeName(), null
-                )
+            buildFunctionCall {
+                source = binaryExpression.toFirSourceElement()
+                calleeReference = buildSimpleNamedReference {
+                    name = conventionCallName ?: operationTokenName.nameAsSafeName()
+                }
                 explicitReceiver = getAsFirExpression(leftArgNode, "No left operand")
                 arguments += rightArgAsFir
             }
@@ -233,7 +237,9 @@ class ExpressionsConverter(
             if (firOperation in FirOperation.ASSIGNMENTS) {
                 return leftArgNode.generateAssignment(null, rightArgAsFir, firOperation) { getAsFirExpression(this) }
             } else {
-                FirOperatorCallImpl(null, firOperation).apply {
+                buildOperatorCall {
+                    source = binaryExpression.toFirSourceElement()
+                    operation = firOperation
                     arguments += getAsFirExpression<FirExpression>(leftArgNode, "No left operand")
                     arguments += rightArgAsFir
                 }
@@ -251,7 +257,7 @@ class ExpressionsConverter(
         toFirOperation: String.() -> FirOperation
     ): FirTypeOperatorCall {
         lateinit var operationTokenName: String
-        var leftArgAsFir: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("No left operand", DiagnosticKind.Syntax))
+        var leftArgAsFir: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No left operand", DiagnosticKind.Syntax))
         lateinit var firType: FirTypeRef
         binaryExpression.forEachChildren {
             when (it.tokenType) {
@@ -260,9 +266,11 @@ class ExpressionsConverter(
                 else -> if (it.isExpression()) leftArgAsFir = getAsFirExpression(it, "No left operand")
             }
         }
-
-        val operation = operationTokenName.toFirOperation()
-        return FirTypeOperatorCallImpl(null, operation, firType).apply {
+        
+        return buildTypeOperatorCall {
+            source = binaryExpression.toFirSourceElement()
+            operation = operationTokenName.toFirOperation()
+            conversionTypeRef = firType
             arguments += leftArgAsFir
         }
     }
@@ -276,7 +284,7 @@ class ExpressionsConverter(
         var firExpression: FirElement? = null
         labeledExpression.forEachChildren {
             when (it.tokenType) {
-                LABEL_QUALIFIER -> context.firLabels += FirLabelImpl(null, it.toString().replace("@", ""))
+                LABEL_QUALIFIER -> context.firLabels += buildLabel { name = it.toString().replace("@", "") }
                 BLOCK -> firExpression = declarationsConverter.convertBlock(it)
                 PROPERTY -> firExpression = declarationsConverter.convertPropertyDeclaration(it)
                 else -> if (it.isExpression()) firExpression = getAsFirExpression(it)
@@ -287,7 +295,7 @@ class ExpressionsConverter(
             context.firLabels.removeLast()
             //println("Unused label: ${labeledExpression.getAsString()}")
         }
-        return firExpression ?: FirErrorExpressionImpl(null, FirSimpleDiagnostic("Empty label", DiagnosticKind.Syntax))
+        return firExpression ?: buildErrorExpression(null, FirSimpleDiagnostic("Empty label", DiagnosticKind.Syntax))
     }
 
     /**
@@ -309,7 +317,8 @@ class ExpressionsConverter(
         val conventionCallName = operationToken.toUnaryName()
         return when {
             operationToken == EXCLEXCL -> {
-                FirCheckNotNullCallImpl(null).apply {
+                buildCheckNotNullCall {
+                    source = unaryExpression.toFirSourceElement()
                     arguments += getAsFirExpression<FirExpression>(argument, "No operand")
                 }
 
@@ -323,14 +332,17 @@ class ExpressionsConverter(
                         prefix = unaryExpression.tokenType == PREFIX_EXPRESSION
                     ) { getAsFirExpression(this) }
                 }
-                FirFunctionCallImpl(null).apply {
-                    calleeReference = FirSimpleNamedReference(null, conventionCallName, null)
+                buildFunctionCall{
+                    source = unaryExpression.toFirSourceElement()
+                    calleeReference = buildSimpleNamedReference { name = conventionCallName }
                     explicitReceiver = getAsFirExpression(argument, "No operand")
                 }
             }
             else -> {
                 val firOperation = operationToken.toFirOperation()
-                FirOperatorCallImpl(null, firOperation).apply {
+                buildOperatorCall {
+                    source = unaryExpression.toFirSourceElement()
+                    operation = firOperation
                     arguments += getAsFirExpression<FirExpression>(argument, "No operand")
                 }
             }
@@ -352,9 +364,10 @@ class ExpressionsConverter(
             }
         }
 
-        return (firExpression as? FirAbstractAnnotatedElement)?.apply {
-            annotations += firAnnotationList
-        } ?: FirErrorExpressionImpl(null, FirSimpleDiagnostic("Strange annotated expression: ${firExpression?.render()}", DiagnosticKind.Syntax))
+        return firExpression?.also {
+            require(it is FirAnnotationContainer)
+            (it.annotations as MutableList<FirAnnotationCall>) += firAnnotationList
+        } ?: buildErrorExpression(null, FirSimpleDiagnostic("Strange annotated expression: ${firExpression?.render()}", DiagnosticKind.Syntax))
     }
 
     /**
@@ -362,12 +375,13 @@ class ExpressionsConverter(
      * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitClassLiteralExpression
      */
     private fun convertClassLiteralExpression(classLiteralExpression: LighterASTNode): FirExpression {
-        var firReceiverExpression: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("No receiver in class literal", DiagnosticKind.Syntax))
+        var firReceiverExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No receiver in class literal", DiagnosticKind.Syntax))
         classLiteralExpression.forEachChildren {
             if (it.isExpression()) firReceiverExpression = getAsFirExpression(it, "No receiver in class literal")
         }
 
-        return FirGetClassCallImpl(null).apply {
+        return buildGetClassCall {
+            source = classLiteralExpression.toFirSourceElement()
             arguments += firReceiverExpression
         }
     }
@@ -395,7 +409,8 @@ class ExpressionsConverter(
             }
         }
 
-        return FirCallableReferenceAccessImpl(null).apply {
+        return buildCallableReferenceAccess {
+            source = callableReferenceExpression.toFirSourceElement()
             calleeReference = firCallableReference.calleeReference as FirNamedReference
             explicitReceiver = firReceiverExpression
             this.safe = safe
@@ -409,7 +424,7 @@ class ExpressionsConverter(
     private fun convertQualifiedExpression(dotQualifiedExpression: LighterASTNode): FirExpression {
         var isSelector = false
         var isSafe = false
-        var firSelector: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax)) //after dot
+        var firSelector: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax)) //after dot
         var firReceiver: FirExpression? = null //before dot
         dotQualifiedExpression.forEachChildren {
             when (it.tokenType) {
@@ -469,15 +484,16 @@ class ExpressionsConverter(
         }
 
         val (calleeReference, explicitReceiver) = when {
-            name != null -> FirSimpleNamedReference(null, name.nameAsSafeName(), null) to null
+            name != null -> buildSimpleNamedReference { this.name = name.nameAsSafeName() } to null
             additionalArgument != null -> {
-                FirSimpleNamedReference(null, OperatorNameConventions.INVOKE, null) to additionalArgument!!
+                buildSimpleNamedReference { this.name = OperatorNameConventions.INVOKE } to additionalArgument!!
             }
-            else -> FirErrorNamedReferenceImpl(null, FirSimpleDiagnostic("Call has no callee", DiagnosticKind.Syntax)) to null
+            else -> buildErrorNamedReference {diagnostic = FirSimpleDiagnostic("Call has no callee", DiagnosticKind.Syntax) } to null
         }
 
-        return if (hasArguments) {
-            FirFunctionCallImpl(null).apply {
+        val builder: FirQualifiedAccessBuilder = if (hasArguments) {
+            FirFunctionCallBuilder().apply {
+                source = callSuffix.toFirSourceElement()
                 this.calleeReference = calleeReference
 
                 context.firFunctionCalls += this
@@ -485,13 +501,15 @@ class ExpressionsConverter(
                 context.firFunctionCalls.removeLast()
             }
         } else {
-            FirQualifiedAccessExpressionImpl(null).apply {
+            FirQualifiedAccessExpressionBuilder().apply {
+                source = callSuffix.toFirSourceElement()
                 this.calleeReference = calleeReference
             }
-        }.apply {
+        }
+        return builder.apply {
             this.explicitReceiver = explicitReceiver
             typeArguments += firTypeArguments
-        }
+        }.build() as FirExpression
     }
 
     /**
@@ -502,7 +520,7 @@ class ExpressionsConverter(
     }
 
     private fun LighterASTNode?.convertShortOrLongStringTemplate(errorReason: String): FirExpression {
-        var firExpression: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax))
         this?.forEachChildren(LONG_TEMPLATE_ENTRY_START, LONG_TEMPLATE_ENTRY_END) {
             firExpression = getAsFirExpression(it, errorReason)
         }
@@ -523,55 +541,65 @@ class ExpressionsConverter(
     private fun convertWhenExpression(whenExpression: LighterASTNode): FirExpression {
         var subjectExpression: FirExpression? = null
         var subjectVariable: FirVariable<*>? = null
+        val whenEntryNodes = mutableListOf<LighterASTNode>()
         val whenEntries = mutableListOf<WhenEntry>()
         whenExpression.forEachChildren {
             when (it.tokenType) {
                 PROPERTY -> subjectVariable = (declarationsConverter.convertPropertyDeclaration(it) as FirVariable<*>).let { variable ->
-                    FirPropertyImpl(
-                        null,
-                        session,
-                        variable.returnTypeRef,
-                        null,
-                        variable.name,
-                        variable.initializer,
-                        null,
-                        false,
-                        FirPropertySymbol(variable.name),
-                        true,
-                        FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
-                    )
+                    buildProperty {
+                        source = it.toFirSourceElement()
+                        session = baseSession
+                        returnTypeRef = variable.returnTypeRef
+                        name = variable.name
+                        initializer = variable.initializer
+                        isVar = false
+                        symbol = FirPropertySymbol(variable.name)
+                        isLocal = true
+                        status = FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
+                    }
                 }
                 DESTRUCTURING_DECLARATION -> subjectExpression =
                     getAsFirExpression(it, "Incorrect when subject expression: ${whenExpression.asText}")
-                WHEN_ENTRY -> whenEntries += convertWhenEntry(it)
+                WHEN_ENTRY -> whenEntryNodes += it
                 else -> if (it.isExpression()) subjectExpression =
                     getAsFirExpression(it, "Incorrect when subject expression: ${whenExpression.asText}")
             }
         }
-
         subjectExpression = subjectVariable?.initializer ?: subjectExpression
         val hasSubject = subjectExpression != null
         val subject = FirWhenSubject()
-        return FirWhenExpressionImpl(null, subjectExpression, subjectVariable).apply {
-            if (hasSubject) {
-                subject.bind(this)
-            }
+        whenEntryNodes.mapTo(whenEntries) { convertWhenEntry(it, subject.takeIf { hasSubject }) }
+        return buildWhenExpression {
+            source = whenExpression.toFirSourceElement()
+            this.subject = subjectExpression
+            this.subjectVariable = subjectVariable
             for (entry in whenEntries) {
                 val branch = entry.firBlock
                 branches += if (!entry.isElse) {
                     if (hasSubject) {
-                        val firCondition = entry.toFirWhenCondition(subject)
-                        FirWhenBranchImpl(null, firCondition, branch)
+                        val firCondition = entry.toFirWhenCondition()
+                        buildWhenBranch {
+                            condition = firCondition
+                            result = branch 
+                        }
                     } else {
                         val firCondition = entry.toFirWhenConditionWithoutSubject()
-                        FirWhenBranchImpl(null, firCondition, branch)
+                        buildWhenBranch {
+                            condition = firCondition
+                            result = branch
+                        }
                     }
                 } else {
-                    FirWhenBranchImpl(
-                        null, FirElseIfTrueCondition(null), branch
-                    )
+                    buildWhenBranch {
+                        condition = buildElseIfTrueCondition()
+                        result = branch
+                    }
                 }
             }
+        }.also {
+            if (hasSubject) {
+                subject.bind(it)
+            }
         }
     }
 
@@ -579,15 +607,15 @@ class ExpressionsConverter(
      * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseWhenEntry
      * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseWhenEntryNotElse
      */
-    private fun convertWhenEntry(whenEntry: LighterASTNode): WhenEntry {
+    private fun convertWhenEntry(whenEntry: LighterASTNode, subject: FirWhenSubject?): WhenEntry {
         var isElse = false
-        var firBlock: FirBlock = FirEmptyExpressionBlock()
+        var firBlock: FirBlock = buildEmptyExpressionBlock()
         val conditions = mutableListOf<FirExpression>()
         whenEntry.forEachChildren {
             when (it.tokenType) {
-                WHEN_CONDITION_EXPRESSION -> conditions += convertWhenConditionExpression(it)
-                WHEN_CONDITION_IN_RANGE -> conditions += convertWhenConditionInRange(it)
-                WHEN_CONDITION_IS_PATTERN -> conditions += convertWhenConditionIsPattern(it)
+                WHEN_CONDITION_EXPRESSION -> conditions += convertWhenConditionExpression(it, subject)
+                WHEN_CONDITION_IN_RANGE -> conditions += convertWhenConditionInRange(it, subject)
+                WHEN_CONDITION_IS_PATTERN -> conditions += convertWhenConditionIsPattern(it, subject)
                 ELSE_KEYWORD -> isElse = true
                 BLOCK -> firBlock = declarationsConverter.convertBlock(it)
                 else -> if (it.isExpression()) firBlock = declarationsConverter.convertBlock(it)
@@ -597,22 +625,31 @@ class ExpressionsConverter(
         return WhenEntry(conditions, firBlock, isElse)
     }
 
-    private fun convertWhenConditionExpression(whenCondition: LighterASTNode): FirExpression {
-        var firExpression: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax))
+    private fun convertWhenConditionExpression(whenCondition: LighterASTNode, subject: FirWhenSubject?): FirExpression {
+        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax))
         whenCondition.forEachChildren {
             when (it.tokenType) {
                 else -> if (it.isExpression()) firExpression = getAsFirExpression(it, "No expression in condition with expression")
             }
         }
+        return if (subject != null) {
+            buildOperatorCall {
+                source = whenCondition.toFirSourceElement()
+                operation = FirOperation.EQ
+                arguments += buildWhenSubjectExpression {
+                    whenSubject = subject
+                }
+                arguments += firExpression
+            }
 
-        return FirOperatorCallImpl(null, FirOperation.EQ).apply {
-            arguments += firExpression
+        } else {
+            firExpression
         }
     }
 
-    private fun convertWhenConditionInRange(whenCondition: LighterASTNode): FirExpression {
+    private fun convertWhenConditionInRange(whenCondition: LighterASTNode, subject: FirWhenSubject?): FirExpression {
         var isNegate = false
-        var firExpression: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("No range in condition with range", DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No range in condition with range", DiagnosticKind.Syntax))
         whenCondition.forEachChildren {
             when {
                 it.tokenType == OPERATION_REFERENCE && it.asText == NOT_IN.value -> isNegate = true
@@ -620,14 +657,26 @@ class ExpressionsConverter(
             }
         }
 
-        val name = if (isNegate) OperatorNameConventions.NOT else SpecialNames.NO_NAME_PROVIDED
-        return FirFunctionCallImpl(null).apply {
-            calleeReference = FirSimpleNamedReference(null, name, null)
-            explicitReceiver = firExpression
+        val subjectExpression = if (subject != null) {
+            buildWhenSubjectExpression {
+                whenSubject = subject
+            }
+        } else {
+            return buildErrorExpression {
+                source = whenCondition.toFirSourceElement()
+                diagnostic = FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax)
+            }
         }
+
+        return firExpression.generateContainsOperation(
+            subjectExpression,
+            inverted = isNegate,
+            base = null, // TODO: replace with FirSourceElement
+            operationReference = null
+        )
     }
 
-    private fun convertWhenConditionIsPattern(whenCondition: LighterASTNode): FirExpression {
+    private fun convertWhenConditionIsPattern(whenCondition: LighterASTNode, subject: FirWhenSubject?): FirExpression {
         lateinit var firOperation: FirOperation
         lateinit var firType: FirTypeRef
         whenCondition.forEachChildren {
@@ -638,7 +687,23 @@ class ExpressionsConverter(
             }
         }
 
-        return FirTypeOperatorCallImpl(null, firOperation, firType)
+        val subjectExpression = if (subject != null) {
+            buildWhenSubjectExpression {
+                whenSubject = subject
+            }
+        } else {
+            return buildErrorExpression {
+                source = whenCondition.toFirSourceElement()
+                diagnostic = FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax)
+            }
+        }
+
+        return buildTypeOperatorCall {
+            source = whenCondition.toFirSourceElement()
+            operation = firOperation
+            conversionTypeRef = firType
+            arguments += subjectExpression
+        }
     }
 
     /**
@@ -646,7 +711,7 @@ class ExpressionsConverter(
      * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitArrayAccessExpression
      */
     private fun convertArrayAccessExpression(arrayAccess: LighterASTNode): FirFunctionCall {
-        var firExpression: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("No array expression", DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No array expression", DiagnosticKind.Syntax))
         val indices: MutableList<FirExpression> = mutableListOf()
         arrayAccess.forEachChildren {
             when (it.tokenType) {
@@ -654,10 +719,15 @@ class ExpressionsConverter(
                 else -> if (it.isExpression()) firExpression = getAsFirExpression(it, "No array expression")
             }
         }
-        return FirFunctionCallImpl(null).apply {
-            calleeReference = FirSimpleNamedReference(null, OperatorNameConventions.GET, null)
+        val getArgument = context.arraySetArgument.remove(arrayAccess)
+        return buildFunctionCall {
+            source = arrayAccess.toFirSourceElement()
+            calleeReference = buildSimpleNamedReference {
+                name = if (getArgument == null) OperatorNameConventions.GET else OperatorNameConventions.SET
+            }
             explicitReceiver = firExpression
             arguments += indices
+            getArgument?.let { arguments += it }
         }
     }
 
@@ -670,7 +740,8 @@ class ExpressionsConverter(
             if (it.isExpression()) firExpressionList += getAsFirExpression<FirExpression>(it, "Incorrect collection literal argument")
         }
 
-        return FirArrayOfCallImpl(null).apply {
+        return buildArrayOfCall {
+            source = expression.toFirSourceElement()
             arguments += firExpressionList
         }
     }
@@ -692,9 +763,9 @@ class ExpressionsConverter(
      * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitSimpleNameExpression
      */
     private fun convertSimpleNameExpression(referenceExpression: LighterASTNode): FirQualifiedAccessExpression {
-        return FirQualifiedAccessExpressionImpl(null).apply {
-            calleeReference =
-                FirSimpleNamedReference(null, referenceExpression.asText.nameAsSafeName(), null)
+        return buildQualifiedAccessExpression {
+            source = referenceExpression.toFirSourceElement()
+            calleeReference = buildSimpleNamedReference { name = referenceExpression.asText.nameAsSafeName() }
         }
     }
 
@@ -704,7 +775,7 @@ class ExpressionsConverter(
      */
     private fun convertDoWhile(doWhileLoop: LighterASTNode): FirElement {
         var block: LighterASTNode? = null
-        var firCondition: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("No condition in do-while loop", DiagnosticKind.Syntax))
+        var firCondition: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No condition in do-while loop", DiagnosticKind.Syntax))
         doWhileLoop.forEachChildren {
             when (it.tokenType) {
                 BODY -> block = it
@@ -712,7 +783,10 @@ class ExpressionsConverter(
             }
         }
 
-        return FirDoWhileLoopImpl(null, firCondition).configure { convertLoopBody(block) }
+        return FirDoWhileLoopBuilder().apply {
+            source = doWhileLoop.toFirSourceElement()
+            condition = firCondition
+        }.configure { convertLoopBody(block) }
     }
 
     /**
@@ -721,7 +795,7 @@ class ExpressionsConverter(
      */
     private fun convertWhile(whileLoop: LighterASTNode): FirElement {
         var block: LighterASTNode? = null
-        var firCondition: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("No condition in while loop", DiagnosticKind.Syntax))
+        var firCondition: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No condition in while loop", DiagnosticKind.Syntax))
         whileLoop.forEachChildren {
             when (it.tokenType) {
                 BODY -> block = it
@@ -729,7 +803,10 @@ class ExpressionsConverter(
             }
         }
 
-        return FirWhileLoopImpl(null, firCondition).configure { convertLoopBody(block) }
+        return FirWhileLoopBuilder().apply {
+            source = whileLoop.toFirSourceElement()
+            condition = firCondition
+        }.configure { convertLoopBody(block) }
     }
 
     /**
@@ -738,7 +815,7 @@ class ExpressionsConverter(
      */
     private fun convertFor(forLoop: LighterASTNode): FirElement {
         var parameter: ValueParameter? = null
-        var rangeExpression: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("No range in for loop", DiagnosticKind.Syntax))
+        var rangeExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No range in for loop", DiagnosticKind.Syntax))
         var blockNode: LighterASTNode? = null
         forLoop.forEachChildren {
             when (it.tokenType) {
@@ -748,57 +825,58 @@ class ExpressionsConverter(
             }
         }
 
-        return FirBlockImpl(null).apply {
+        return buildBlock {
+            source = forLoop.toFirSourceElement()
             val rangeVal =
-                generateTemporaryVariable(this@ExpressionsConverter.session, null, Name.special("<range>"), rangeExpression)
+                generateTemporaryVariable(this@ExpressionsConverter.baseSession, null, Name.special("<range>"), rangeExpression)
             statements += rangeVal
             val iteratorVal = generateTemporaryVariable(
-                this@ExpressionsConverter.session, null, Name.special("<iterator>"),
-                FirFunctionCallImpl(null).apply {
-                    calleeReference = FirSimpleNamedReference(null, Name.identifier("iterator"), null)
+                this@ExpressionsConverter.baseSession, null, Name.special("<iterator>"),
+                buildFunctionCall {
+                    calleeReference = buildSimpleNamedReference { name = Name.identifier("iterator") }
                     explicitReceiver = generateResolvedAccessExpression(null, rangeVal)
                 }
             )
             statements += iteratorVal
-            statements += FirWhileLoopImpl(
-                null,
-                FirFunctionCallImpl(null).apply {
-                    calleeReference = FirSimpleNamedReference(null, Name.identifier("hasNext"), null)
+            statements += FirWhileLoopBuilder().apply {
+                source = forLoop.toFirSourceElement()
+                condition = buildFunctionCall {
+                    calleeReference = buildSimpleNamedReference { name = Name.identifier("hasNext") }
                     explicitReceiver = generateResolvedAccessExpression(null, iteratorVal)
                 }
-            ).configure {
+            }.configure {
                 // NB: just body.toFirBlock() isn't acceptable here because we need to add some statements
-                val block = FirBlockImpl(null).apply {
+                buildBlock block@{
+                    source = blockNode?.toFirSourceElement()
                     statements += convertLoopBody(blockNode).statements
-                }
-                if (parameter != null) {
+                    if (parameter == null) return@block
                     val multiDeclaration = parameter!!.destructuringDeclaration
                     val firLoopParameter = generateTemporaryVariable(
-                        this@ExpressionsConverter.session, null,
+                        this@ExpressionsConverter.baseSession, null,
                         if (multiDeclaration != null) Name.special("<destruct>") else parameter!!.firValueParameter.name,
-                        FirFunctionCallImpl(null).apply {
-                            calleeReference = FirSimpleNamedReference(null, Name.identifier("next"), null)
+                        buildFunctionCall {
+                            calleeReference = buildSimpleNamedReference { name = Name.identifier("next") }
                             explicitReceiver = generateResolvedAccessExpression(null, iteratorVal)
                         },
                         parameter!!.firValueParameter.returnTypeRef
                     )
                     if (multiDeclaration != null) {
                         val destructuringBlock = generateDestructuringBlock(
-                            this@ExpressionsConverter.session,
+                            this@ExpressionsConverter.baseSession,
                             multiDeclaration,
                             firLoopParameter,
                             tmpVariable = true
                         )
                         if (destructuringBlock is FirBlock) {
                             for ((index, statement) in destructuringBlock.statements.withIndex()) {
-                                block.statements.add(index, statement)
+                                statements.add(index, statement)
                             }
                         }
                     } else {
-                        block.statements.add(0, firLoopParameter)
+                        statements.add(0, firLoopParameter)
                     }
+
                 }
-                block
             }
         }
     }
@@ -819,7 +897,7 @@ class ExpressionsConverter(
 
         return when {
             firStatement != null -> FirSingleExpressionBlock(firStatement!!)
-            firBlock == null -> FirEmptyExpressionBlock()
+            firBlock == null -> buildEmptyExpressionBlock()
             else -> firBlock!!
         }
     }
@@ -839,10 +917,16 @@ class ExpressionsConverter(
                 FINALLY -> finallyBlock = convertFinally(it)
             }
         }
-        return FirTryExpressionImpl(null, tryBlock, finallyBlock).apply {
+        return buildTryExpression {
+            source = tryExpression.toFirSourceElement()
+            this.tryBlock = tryBlock
+            this.finallyBlock = finallyBlock
             for ((parameter, block) in catchClauses) {
                 if (parameter == null) continue
-                catches += FirCatchImpl(null, parameter.firValueParameter, block)
+                catches += buildCatch {
+                    this.parameter = parameter.firValueParameter
+                    this.block = block
+                }
             }
         }
     }
@@ -882,7 +966,7 @@ class ExpressionsConverter(
      * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitIfExpression
      */
     private fun convertIfExpression(ifExpression: LighterASTNode): FirExpression {
-        var firCondition: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("If statement should have condition", DiagnosticKind.Syntax))
+        var firCondition: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("If statement should have condition", DiagnosticKind.Syntax))
         var thenBlock: LighterASTNode? = null
         var elseBlock: LighterASTNode? = null
         ifExpression.forEachChildren {
@@ -893,14 +977,21 @@ class ExpressionsConverter(
             }
         }
 
-        return FirWhenExpressionImpl(null, null, null).apply {
+        return buildWhenExpression {
             val trueBranch = convertLoopBody(thenBlock)
-            branches += FirWhenBranchImpl(null, firCondition, trueBranch)
-            val elseBranch = convertLoopBody(elseBlock)
-            if (elseBranch !is FirEmptyExpressionBlock) {
-                branches += FirWhenBranchImpl(
-                    null, FirElseIfTrueCondition(null), elseBranch
-                )
+            branches += buildWhenBranch {
+                source = thenBlock?.toFirSourceElement()
+                condition = firCondition
+                result = trueBranch
+            }
+            if (elseBlock != null) {
+                val elseBranch = convertLoopBody(elseBlock)
+                branches += buildWhenBranch {
+                    source = elseBlock?.toFirSourceElement()
+                    condition = buildElseIfTrueCondition()
+                    result = elseBranch
+                }
+
             }
         }
     }
@@ -919,7 +1010,10 @@ class ExpressionsConverter(
             }
         }
 
-        return (if (isBreak) FirBreakExpressionImpl(null) else FirContinueExpressionImpl(null)).bindLabel(jump)
+        val jumpBuilder = if (isBreak) FirBreakExpressionBuilder() else FirContinueExpressionBuilder()
+        return jumpBuilder.apply {
+            source = jump.toFirSourceElement()
+        }.bindLabel(jump).build()
     }
 
     /**
@@ -928,7 +1022,7 @@ class ExpressionsConverter(
      */
     private fun convertReturn(returnExpression: LighterASTNode): FirExpression {
         var labelName: String? = null
-        var firExpression: FirExpression = FirUnitExpression(null)
+        var firExpression: FirExpression = buildUnitExpression()
         returnExpression.forEachChildren {
             when (it.tokenType) {
                 LABEL_QUALIFIER -> labelName = it.getAsStringWithoutBacktick().replace("@", "")
@@ -944,12 +1038,15 @@ class ExpressionsConverter(
      * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitThrowExpression
      */
     private fun convertThrow(throwExpression: LighterASTNode): FirExpression {
-        var firExpression: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("Nothing to throw", DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("Nothing to throw", DiagnosticKind.Syntax))
         throwExpression.forEachChildren {
             if (it.isExpression()) firExpression = getAsFirExpression(it, "Nothing to throw")
         }
 
-        return FirThrowExpressionImpl(null, firExpression)
+        return buildThrowExpression {
+            source = throwExpression.toFirSourceElement()
+            exception = firExpression
+        }
     }
 
     /**
@@ -958,7 +1055,10 @@ class ExpressionsConverter(
      */
     private fun convertThisExpression(thisExpression: LighterASTNode): FirQualifiedAccessExpression {
         val label: String? = thisExpression.getLabelName()
-        return FirThisReceiverExpressionImpl(null, FirExplicitThisReference(null, label))
+        return buildThisReceiverExpression {
+            source = thisExpression.toFirSourceElement()
+            calleeReference = buildExplicitThisReference { labelName = label }
+        }
     }
 
     /**
@@ -973,8 +1073,11 @@ class ExpressionsConverter(
             }
         }
 
-        return FirQualifiedAccessExpressionImpl(null).apply {
-            calleeReference = FirExplicitSuperReference(null, superTypeRef)
+        return buildQualifiedAccessExpression {
+            source = superExpression.toFirSourceElement()
+            calleeReference = buildExplicitSuperReference {
+                this.superTypeRef = superTypeRef
+            }
         }
     }
 
@@ -987,7 +1090,10 @@ class ExpressionsConverter(
                 VALUE_ARGUMENT -> container += convertValueArgument(node)
                 LAMBDA_EXPRESSION,
                 LABELED_EXPRESSION,
-                ANNOTATED_EXPRESSION -> container += FirLambdaArgumentExpressionImpl(null, getAsFirExpression(node))
+                ANNOTATED_EXPRESSION -> container += buildLambdaArgumentExpression {
+                    source = valueArguments.toFirSourceElement()
+                    expression = getAsFirExpression(node)
+                }
             }
         }
     }
@@ -999,7 +1105,7 @@ class ExpressionsConverter(
     private fun convertValueArgument(valueArgument: LighterASTNode): FirExpression {
         var identifier: String? = null
         var isSpread = false
-        var firExpression: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("Argument is absent", DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("Argument is absent", DiagnosticKind.Syntax))
         valueArgument.forEachChildren {
             when (it.tokenType) {
                 VALUE_ARGUMENT_NAME -> identifier = it.asText
@@ -1010,13 +1116,16 @@ class ExpressionsConverter(
             }
         }
         return when {
-            identifier != null -> FirNamedArgumentExpressionImpl(
-                null,
-                firExpression,
-                isSpread,
-                identifier.nameAsSafeName()
-            )
-            isSpread -> FirSpreadArgumentExpressionImpl(null, firExpression)
+            identifier != null -> buildNamedArgumentExpression {
+                source = valueArgument.toFirSourceElement()
+                expression = firExpression
+                this.isSpread = isSpread
+                name = identifier.nameAsSafeName()
+            }
+            isSpread -> buildSpreadArgumentExpression {
+                source = valueArgument.toFirSourceElement()
+                expression = firExpression
+            }
             else -> firExpression
         }
     }

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

@@ -13,8 +13,8 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.Modifier
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.FirUserTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildUserTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirQualifierPartImpl
-import org.jetbrains.kotlin.fir.types.impl.FirUserTypeRefImpl
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
 
@@ -65,15 +65,9 @@ class ClassWrapper(
     }
 
     fun getFirUserTypeFromClassName(): FirUserTypeRef {
-        val qualifier = FirQualifierPartImpl(
-            className
-        )
-
-        return FirUserTypeRefImpl(
-            null,
-            false
-        ).apply {
-            this.qualifier.add(qualifier)
+        return buildUserTypeRef {
+            isMarkedNullable = false
+            qualifier.add(FirQualifierPartImpl(className))
         }
     }
 }

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

@@ -9,19 +9,19 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.builder.convertToArrayType
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.builder.buildProperty
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
-import org.jetbrains.kotlin.fir.declarations.impl.FirPropertyImpl
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
-import org.jetbrains.kotlin.fir.expressions.impl.FirQualifiedAccessExpressionImpl
+import org.jetbrains.kotlin.fir.expressions.builder.buildQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.Modifier
-import org.jetbrains.kotlin.fir.references.impl.FirPropertyFromParameterResolvedNamedReference
+import org.jetbrains.kotlin.fir.references.builder.buildPropertyFromParameterResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
 
 class ValueParameter(
     private val isVal: Boolean,
@@ -41,34 +41,30 @@ class ValueParameter(
             type = type.convertToArrayType()
         }
         if (type is FirImplicitTypeRef) {
-            type = FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Incomplete code", DiagnosticKind.Syntax))
+            type = buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Incomplete code", DiagnosticKind.Syntax) }
         }
 
-        val status = FirDeclarationStatusImpl(modifiers.getVisibility(), modifiers.getModality()).apply {
-            isExpect = modifiers.hasExpect()
-            isActual = modifiers.hasActual()
-            isOverride = modifiers.hasOverride()
-            isConst = false
-            isLateInit = false
-        }
-
-        return FirPropertyImpl(
-            null,
-            session,
-            type,
-            null,
-            name,
-            FirQualifiedAccessExpressionImpl(null).apply {
-                calleeReference = FirPropertyFromParameterResolvedNamedReference(
-                    null, name, this@ValueParameter.firValueParameter.symbol
-                )
-            },
-            null,
-            this.isVar,
-            FirPropertySymbol(callableId),
-            false,
-            status
-        ).apply {
+        return buildProperty {
+            source = firValueParameter.source
+            this.session = session
+            returnTypeRef = type
+            this.name = name
+            initializer = buildQualifiedAccessExpression {
+                calleeReference = buildPropertyFromParameterResolvedNamedReference {
+                    this.name =  name
+                    resolvedSymbol = this@ValueParameter.firValueParameter.symbol
+                }
+            }
+            isVar = this@ValueParameter.isVar
+            symbol = FirPropertySymbol(callableId)
+            isLocal = false
+            status = FirDeclarationStatusImpl(modifiers.getVisibility(), modifiers.getModality()).apply {
+                isExpect = modifiers.hasExpect()
+                isActual = modifiers.hasActual()
+                isOverride = modifiers.hasOverride()
+                isConst = false
+                isLateInit = false
+            }
             annotations += this@ValueParameter.firValueParameter.annotations
             getter = FirDefaultPropertyGetter(null, session, type, modifiers.getVisibility())
             setter = if (this.isVar) FirDefaultPropertySetter(null, session, type, modifiers.getVisibility()) else null

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

@@ -6,26 +6,24 @@
 package org.jetbrains.kotlin.fir.lightTree.fir
 
 import org.jetbrains.kotlin.fir.FirWhenSubject
-import org.jetbrains.kotlin.fir.builder.generateContainsOperation
 import org.jetbrains.kotlin.fir.builder.generateLazyLogicalOperation
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
-import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirOperatorCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirTypeOperatorCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirWhenSubjectExpressionImpl
-import org.jetbrains.kotlin.util.OperatorNameConventions
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirOperatorCall
+import org.jetbrains.kotlin.fir.expressions.buildErrorExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildWhenSubjectExpression
 
 data class WhenEntry(
     val conditions: List<FirExpression>,
     val firBlock: FirBlock,
     val isElse: Boolean = false
 ) {
-    fun toFirWhenCondition(subject: FirWhenSubject): FirExpression {
+    fun toFirWhenCondition(): FirExpression {
         var firCondition: FirExpression? = null
         for (condition in conditions) {
-            val firConditionElement = condition.toFirWhenCondition(subject)
+            val firConditionElement = condition.toFirWhenCondition()
             firCondition = when (firCondition) {
                 null -> firConditionElement
                 else -> firCondition.generateLazyLogicalOperation(firConditionElement, false, null)
@@ -34,34 +32,15 @@ data class WhenEntry(
         return firCondition!!
     }
 
-    private fun FirExpression.toFirWhenCondition(subject: FirWhenSubject): FirExpression {
-        val firSubjectExpression = FirWhenSubjectExpressionImpl(null, subject)
-        return when (this) {
-            is FirOperatorCallImpl -> {
-                this.apply {
-                    arguments.add(0, firSubjectExpression)
-                }
-            }
-            is FirFunctionCall -> {
-                val firExpression = this.explicitReceiver!!
-                val isNegate = this.calleeReference.name == OperatorNameConventions.NOT
-                firExpression.generateContainsOperation(firSubjectExpression, isNegate, null, null)
-            }
-            is FirTypeOperatorCallImpl -> {
-                this.apply {
-                    arguments += firSubjectExpression
-                }
-            }
-            else -> {
-                FirErrorExpressionImpl(null, FirSimpleDiagnostic("Unsupported when condition: ${this.javaClass}", DiagnosticKind.Syntax))
-            }
-        }
+    private fun FirExpression.toFirWhenCondition(): FirExpression {
+        return this
     }
 
     fun toFirWhenConditionWithoutSubject(): FirExpression {
-        return when (val condition = conditions.first()) {
-            is FirOperatorCallImpl -> condition.arguments.first()
-            else -> FirErrorExpressionImpl(null, FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax))
+        return when (val condition = conditions.firstOrNull()) {
+//            is FirOperatorCall -> condition.arguments.first()
+            null -> buildErrorExpression(null, FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax))
+            else -> condition
         }
     }
 }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/Modifier.kt

@@ -9,9 +9,7 @@ import com.intellij.lang.LighterASTNode
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.CLASS_MODIFIER
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.FUNCTION_MODIFIER
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.INHERITANCE_MODIFIER
@@ -20,11 +18,8 @@ import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PARAMETER_MO
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PLATFORM_MODIFIER
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PROPERTY_MODIFIER
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VISIBILITY_MODIFIER
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
-import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 class Modifier(
-    override val source: FirSourceElement? = null,
     private val classModifiers: MutableList<ClassModifier> = mutableListOf(),
     private val memberModifiers: MutableList<MemberModifier> = mutableListOf(),
     private val visibilityModifiers: MutableList<VisibilityModifier> = mutableListOf(),
@@ -33,8 +28,8 @@ class Modifier(
     private val inheritanceModifiers: MutableList<InheritanceModifier> = mutableListOf(),
     private val parameterModifiers: MutableList<ParameterModifier> = mutableListOf(),
     private val platformModifiers: MutableList<PlatformModifier> = mutableListOf()
-) : FirAbstractAnnotatedElement {
-    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+) {
+    val annotations: MutableList<FirAnnotationCall> = mutableListOf()
 
     fun addModifier(modifier: LighterASTNode) {
         val tokenType = modifier.tokenType
@@ -157,10 +152,4 @@ class Modifier(
     fun hasActual(): Boolean {
         return platformModifiers.contains(PlatformModifier.ACTUAL) || platformModifiers.contains(PlatformModifier.IMPL)
     }
-
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
-
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
-        return this
-    }
 }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeModifier.kt

@@ -6,18 +6,11 @@
 package org.jetbrains.kotlin.fir.lightTree.fir.modifier
 
 import com.intellij.lang.LighterASTNode
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
-import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.lexer.KtTokens
 
-class TypeModifier(
-    override val source: FirSourceElement? = null,
-    var hasSuspend: Boolean = false
-) : FirAbstractAnnotatedElement {
-    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+class TypeModifier(var hasSuspend: Boolean = false) {
+    val annotations: MutableList<FirAnnotationCall> = mutableListOf()
 
     fun addModifier(modifier: LighterASTNode) {
         when (modifier.tokenType) {
@@ -28,10 +21,4 @@ class TypeModifier(
     fun hasNoAnnotations(): Boolean {
         return annotations.isEmpty()
     }
-
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
-
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
-        return this
-    }
 }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeParameterModifier.kt

@@ -6,21 +6,16 @@
 package org.jetbrains.kotlin.fir.lightTree.fir.modifier
 
 import com.intellij.lang.LighterASTNode
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.REIFICATION_MODIFIER
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VARIANCE_MODIFIER
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
-import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.types.Variance
 
 class TypeParameterModifier(
-    override val source: FirSourceElement? = null,
     private val varianceModifiers: MutableList<VarianceModifier> = mutableListOf(),
     private var reificationModifier: ReificationModifier? = null
-) : FirAbstractAnnotatedElement {
-    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+) {
+    val annotations: MutableList<FirAnnotationCall> = mutableListOf()
 
     fun addModifier(modifier: LighterASTNode) {
         val tokenType = modifier.tokenType
@@ -42,10 +37,4 @@ class TypeParameterModifier(
     fun hasReified(): Boolean {
         return reificationModifier == ReificationModifier.REIFIED
     }
-
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
-
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
-        return this
-    }
 }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeProjectionModifier.kt

@@ -8,17 +8,14 @@ package org.jetbrains.kotlin.fir.lightTree.fir.modifier
 import com.intellij.lang.LighterASTNode
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VARIANCE_MODIFIER
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
-import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.types.Variance
 
 class TypeProjectionModifier(
-    override val source: FirSourceElement? = null,
+    val source: FirSourceElement? = null,
     private val varianceModifiers: MutableList<VarianceModifier> = mutableListOf()
-) : FirAbstractAnnotatedElement {
-    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+) {
+    val annotations: MutableList<FirAnnotationCall> = mutableListOf()
 
     fun addModifier(modifier: LighterASTNode) {
         val tokenType = modifier.tokenType
@@ -34,10 +31,4 @@ class TypeProjectionModifier(
             else -> Variance.INVARIANT
         }
     }
-
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
-
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
-        return this
-    }
 }

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt

@@ -8,24 +8,35 @@ package org.jetbrains.kotlin.fir.builder
 import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.KtNodeTypes.*
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirErrorFunctionImpl
+import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.addDeclaration
+import org.jetbrains.kotlin.fir.declarations.builder.AbstractFirRegularClassBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.buildErrorFunction
+import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.*
+import org.jetbrains.kotlin.fir.expressions.builder.*
+import org.jetbrains.kotlin.fir.expressions.impl.buildSingleExpressionBlock
 import org.jetbrains.kotlin.fir.references.FirReference
-import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
-import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
+import org.jetbrains.kotlin.fir.references.builder.*
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.FirErrorFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.lexer.KtTokens.CLOSING_QUOTE
 import org.jetbrains.kotlin.lexer.KtTokens.OPEN_QUOTE
 import org.jetbrains.kotlin.name.FqName
@@ -34,15 +45,16 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 import org.jetbrains.kotlin.psi.KtUnaryExpression
 import org.jetbrains.kotlin.resolve.constants.evaluate.*
-import org.jetbrains.kotlin.util.OperatorNameConventions
 
 //T can be either PsiElement, or LighterASTNode
-abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context = Context()) {
+abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Context<T> = Context()) {
 
-    protected val implicitUnitType = session.builtinTypes.unitType
-    protected val implicitAnyType = session.builtinTypes.anyType
-    protected val implicitEnumType = session.builtinTypes.enumType
-    protected val implicitAnnotationType = session.builtinTypes.annotationType
+    abstract fun T.toFirSourceElement(): FirSourceElement
+
+    protected val implicitUnitType = baseSession.builtinTypes.unitType
+    protected val implicitAnyType = baseSession.builtinTypes.anyType
+    protected val implicitEnumType = baseSession.builtinTypes.enumType
+    protected val implicitAnnotationType = baseSession.builtinTypes.annotationType
 
     abstract val T.elementType: IElementType
     abstract val T.asText: String
@@ -56,9 +68,11 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
     /**** Class name utils ****/
     inline fun <T> withChildClassName(name: Name, l: () -> T): T {
         context.className = context.className.child(name)
-        val t = l()
-        context.className = context.className.parent()
-        return t
+        return try {
+            l()
+        } finally {
+            context.className = context.className.parent()
+        }
     }
 
     fun callableIdForName(name: Name, local: Boolean = false) =
@@ -93,63 +107,47 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
     }
 
     fun FirExpression.toReturn(baseSource: FirSourceElement? = source, labelName: String? = null): FirReturnExpression {
-        return FirReturnExpressionImpl(
-            baseSource,
-            this
-        ).apply {
-            target = FirFunctionTarget(labelName)
+        return buildReturnExpression {
+            fun FirFunctionTarget.bindToErrorFunction(message: String, kind: DiagnosticKind) {
+                bind(
+                    buildErrorFunction {
+                        source = baseSource
+                        session = this@BaseFirBuilder.baseSession
+                        diagnostic = FirSimpleDiagnostic(message, kind)
+                        symbol = FirErrorFunctionSymbol()
+                    }
+                )
+            }
+
+            source = baseSource
+            result = this@toReturn
             if (labelName == null) {
-                val lastFunction = context.firFunctions.lastOrNull { !(it is FirAnonymousFunction && it.isLambda) }
-                if (lastFunction != null) {
-                    target.bind(lastFunction)
-                } else {
-                    target.bind(
-                        FirErrorFunctionImpl(
-                            source,
-                            this@BaseFirBuilder.session,
-                            FirSimpleDiagnostic("Cannot bind unlabeled return to a function", DiagnosticKind.ReturnNotAllowed),
-                            FirErrorFunctionSymbol()
-                        )
-                    )
+                target = context.firFunctionTargets.lastOrNull { !it.isLambda } ?: FirFunctionTarget(labelName, isLambda = false).apply {
+                    bindToErrorFunction("Cannot bind unlabeled return to a function", DiagnosticKind.ReturnNotAllowed)
                 }
             } else {
-                for (firFunction in context.firFunctions.asReversed()) {
-                    when (firFunction) {
-                        is FirAnonymousFunction -> {
-                            if (firFunction.label?.name == labelName) {
-                                target.bind(firFunction)
-                                return@apply
-                            }
-                        }
-                        is FirSimpleFunction -> {
-                            if (firFunction.name.asString() == labelName) {
-                                target.bind(firFunction)
-                                return@apply
-                            }
-                        }
+                for (functionTarget in context.firFunctionTargets.asReversed()) {
+                    if (functionTarget.labelName == labelName) {
+                        target = functionTarget
+                        return@buildReturnExpression
                     }
                 }
-                target.bind(
-                    FirErrorFunctionImpl(
-                        source,
-                        this@BaseFirBuilder.session,
-                        FirSimpleDiagnostic("Cannot bind label $labelName to a function", DiagnosticKind.UnresolvedLabel),
-                        FirErrorFunctionSymbol()
-                    )
-                )
+                target = FirFunctionTarget(labelName, false).apply {
+                    bindToErrorFunction("Cannot bind label $labelName to a function", DiagnosticKind.UnresolvedLabel)
+                }
             }
         }
     }
 
-    fun KtClassOrObject?.toDelegatedSelfType(firClass: FirRegularClass): FirResolvedTypeRef {
-        return FirResolvedTypeRefImpl(
-            this?.toFirSourceElement(),
-            ConeClassLikeTypeImpl(
+    fun T?.toDelegatedSelfType(firClass: AbstractFirRegularClassBuilder): FirResolvedTypeRef {
+        return buildResolvedTypeRef {
+            source = this@toDelegatedSelfType?.toFirSourceElement()
+            type = ConeClassLikeTypeImpl(
                 firClass.symbol.toLookupTag(),
                 firClass.typeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) }.toTypedArray(),
                 false
             )
-        )
+        }
     }
 
     fun typeParametersFromSelfType(delegatedSelfTypeRef: FirTypeRef): List<FirTypeParameter> {
@@ -159,40 +157,43 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
             ?: emptyList()
     }
 
-    fun FirAbstractLoop.configure(generateBlock: () -> FirBlock): FirAbstractLoop {
+    fun FirLoopBuilder.configure(generateBlock: () -> FirBlock): FirLoop {
         label = context.firLabels.pop()
-        context.firLoops += this
+        val target = FirLoopTarget(label?.name)
+        context.firLoopTargets += target
         block = generateBlock()
-        context.firLoops.removeLast()
-        return this
+        val loop = build()
+        context.firLoopTargets.removeLast()
+        target.bind(loop)
+        return loop
     }
 
-    fun FirAbstractLoopJump.bindLabel(expression: T): FirAbstractLoopJump {
+    fun FirLoopJumpBuilder.bindLabel(expression: T): FirLoopJumpBuilder {
         val labelName = expression.getLabelName()
-        target = FirLoopTarget(labelName)
-        val lastLoop = context.firLoops.lastOrNull()
+        val lastLoopTarget = context.firLoopTargets.lastOrNull()
         if (labelName == null) {
-            if (lastLoop != null) {
-                target.bind(lastLoop)
-            } else {
-                target.bind(
-                    FirErrorLoop(
-                        expression.getSourceOrNull(), FirSimpleDiagnostic("Cannot bind unlabeled jump to a loop", DiagnosticKind.Syntax)
+            target = lastLoopTarget ?: FirLoopTarget(labelName).apply {
+                bind(
+                    buildErrorLoop(
+                        expression.getSourceOrNull(),
+                        FirSimpleDiagnostic("Cannot bind unlabeled jump to a loop", DiagnosticKind.Syntax)
                     )
                 )
             }
         } else {
-            for (firLoop in context.firLoops.asReversed()) {
-                if (firLoop.label?.name == labelName) {
-                    target.bind(firLoop)
+            for (firLoopTarget in context.firLoopTargets.asReversed()) {
+                if (firLoopTarget.labelName == labelName) {
+                    target = firLoopTarget
                     return this
                 }
             }
-            target.bind(
-                FirErrorLoop(
-                    expression.getSourceOrNull(), FirSimpleDiagnostic("Cannot bind label $labelName to a loop", DiagnosticKind.Syntax)
+            target = FirLoopTarget(labelName).apply {
+                bind(
+                    buildErrorLoop(
+                        expression.getSourceOrNull(), FirSimpleDiagnostic("Cannot bind label $labelName to a loop", DiagnosticKind.Syntax)
+                    )
                 )
-            )
+            }
         }
         return this
     }
@@ -213,13 +214,13 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
         return when (type) {
             INTEGER_CONSTANT -> {
                 val kind = when {
-                    convertedText !is Long -> return FirErrorExpressionImpl(
-                        expression.getSourceOrNull(),
-                        FirSimpleDiagnostic(
+                    convertedText !is Long -> return buildErrorExpression {
+                        source = expression.getSourceOrNull()
+                        diagnostic = FirSimpleDiagnostic(
                             "Incorrect constant expression: $text",
                             DiagnosticKind.IllegalConstExpression
                         )
-                    )
+                    }
 
                     hasLongSuffix(text) || hasUnsignedSuffix(text) || hasUnsignedLongSuffix(text) -> {
                         FirConstKind.Long
@@ -230,7 +231,7 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                     }
                 }
 
-                FirConstExpressionImpl(
+                buildConstOrErrorExpression(
                     expression.getSourceOrNull(),
                     kind,
                     convertedText,
@@ -239,25 +240,39 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
             }
             FLOAT_CONSTANT ->
                 if (convertedText is Float) {
-                    FirConstExpressionImpl(
-                        expression.getSourceOrNull(), FirConstKind.Float, convertedText,
+                    buildConstOrErrorExpression(
+                        expression.getSourceOrNull(),
+                        FirConstKind.Float,
+                        convertedText,
                         FirSimpleDiagnostic("Incorrect float: $text", DiagnosticKind.Syntax)
                     )
                 } else {
-                    FirConstExpressionImpl(
-                        expression.getSourceOrNull(), FirConstKind.Double, convertedText as Double,
+                    buildConstOrErrorExpression(
+                        expression.getSourceOrNull(),
+                        FirConstKind.Double,
+                        convertedText as Double,
                         FirSimpleDiagnostic("Incorrect double: $text", DiagnosticKind.Syntax)
                     )
                 }
             CHARACTER_CONSTANT ->
-                FirConstExpressionImpl(
-                    expression.getSourceOrNull(), FirConstKind.Char, text.parseCharacter(),
+                buildConstOrErrorExpression(
+                    expression.getSourceOrNull(),
+                    FirConstKind.Char,
+                    text.parseCharacter(),
                     FirSimpleDiagnostic("Incorrect character: $text", DiagnosticKind.Syntax)
                 )
             BOOLEAN_CONSTANT ->
-                FirConstExpressionImpl(expression.getSourceOrNull(), FirConstKind.Boolean, convertedText as Boolean)
+                buildConstExpression(
+                    expression.getSourceOrNull(),
+                    FirConstKind.Boolean,
+                    convertedText as Boolean
+                )
             NULL ->
-                FirConstExpressionImpl(expression.getSourceOrNull(), FirConstKind.Null, null)
+                buildConstExpression(
+                    expression.getSourceOrNull(),
+                    FirConstKind.Null,
+                    null
+                )
             else ->
                 throw AssertionError("Unknown literal type: $type, $text")
         }
@@ -267,53 +282,48 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
         base: KtStringTemplateExpression?,
         convertTemplateEntry: T?.(String) -> FirExpression
     ): FirExpression {
-        val sb = StringBuilder()
-        var hasExpressions = false
-        var result: FirExpression? = null
-        var callCreated = false
-        L@ for (entry in this) {
-            if (entry == null) continue
-            val nextArgument = when (entry.elementType) {
-                OPEN_QUOTE, CLOSING_QUOTE -> continue@L
-                LITERAL_STRING_TEMPLATE_ENTRY -> {
-                    sb.append(entry.asText)
-                    FirConstExpressionImpl(entry.getSourceOrNull(), FirConstKind.String, entry.asText)
-                }
-                ESCAPE_STRING_TEMPLATE_ENTRY -> {
-                    sb.append(entry.unescapedValue)
-                    FirConstExpressionImpl(entry.getSourceOrNull(), FirConstKind.String, entry.unescapedValue)
-                }
-                SHORT_STRING_TEMPLATE_ENTRY, LONG_STRING_TEMPLATE_ENTRY -> {
-                    hasExpressions = true
-                    val firExpression = entry.convertTemplateEntry("Incorrect template argument")
-                    val source = firExpression.source
-                    FirFunctionCallImpl(source).apply {
-                        explicitReceiver = firExpression
-                        calleeReference = FirSimpleNamedReference(source, Name.identifier("toString"), candidateSymbol = null)
+        return buildStringConcatenationCall {
+            val sb = StringBuilder()
+            var hasExpressions = false
+            L@ for (entry in this@toInterpolatingCall) {
+                if (entry == null) continue
+                arguments += when (entry.elementType) {
+                    OPEN_QUOTE, CLOSING_QUOTE -> continue@L
+                    LITERAL_STRING_TEMPLATE_ENTRY -> {
+                        sb.append(entry.asText)
+                        buildConstExpression(entry.getSourceOrNull(), FirConstKind.String, entry.asText)
                     }
-                }
-                else -> {
-                    hasExpressions = true
-                    FirErrorExpressionImpl(
-                        entry.getSourceOrNull(), FirSimpleDiagnostic("Incorrect template entry: ${entry.asText}", DiagnosticKind.Syntax)
-                    )
-                }
-            }
-            result = when {
-                result == null -> nextArgument
-                callCreated && result is FirStringConcatenationCallImpl -> result.apply {
-                    arguments += nextArgument
-                }
-                else -> {
-                    callCreated = true
-                    FirStringConcatenationCallImpl(base?.toFirSourceElement()).apply {
-                        arguments += result!!
-                        arguments += nextArgument
+                    ESCAPE_STRING_TEMPLATE_ENTRY -> {
+                        sb.append(entry.unescapedValue)
+                        buildConstExpression(entry.getSourceOrNull(), FirConstKind.String, entry.unescapedValue)
+                    }
+                    SHORT_STRING_TEMPLATE_ENTRY, LONG_STRING_TEMPLATE_ENTRY -> {
+                        hasExpressions = true
+                        val firExpression = entry.convertTemplateEntry("Incorrect template argument")
+                        val source = firExpression.source
+                        buildFunctionCall {
+                            this.source = source
+                            explicitReceiver = firExpression
+                            calleeReference = buildSimpleNamedReference {
+                                this.source = source
+                                name = Name.identifier("toString")
+                            }
+                        }
+                    }
+                    else -> {
+                        hasExpressions = true
+                        buildErrorExpression {
+                            source = entry.getSourceOrNull()
+                            diagnostic = FirSimpleDiagnostic("Incorrect template entry: ${entry.asText}", DiagnosticKind.Syntax)
+                        }
                     }
                 }
             }
+            source = base?.toFirSourceElement()
+            // Fast-pass if there is no non-const string expressions
+            if (!hasExpressions) return buildConstExpression(source, FirConstKind.String, sb.toString())
+            arguments.singleOrNull()?.let { return it }
         }
-        return if (hasExpressions) result!! else FirConstExpressionImpl(base?.toFirSourceElement(), FirConstKind.String, sb.toString())
     }
 
     /**
@@ -348,19 +358,27 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
         convert: T.() -> FirExpression
     ): FirExpression {
         if (argument == null) {
-            return FirErrorExpressionImpl(argument, FirSimpleDiagnostic("Inc/dec without operand", DiagnosticKind.Syntax))
+            return buildErrorExpression {
+                source = argument
+                diagnostic = FirSimpleDiagnostic("Inc/dec without operand", DiagnosticKind.Syntax)
+            }
         }
-        val source = baseExpression?.toFirSourceElement()
-        return FirBlockImpl(source).apply {
+        return buildBlock {
+            val baseSource = baseExpression?.toFirSourceElement()
+            source = baseSource
             val tempName = Name.special("<unary>")
-            val temporaryVariable = generateTemporaryVariable(this@BaseFirBuilder.session, source, tempName, argument.convert())
+            val temporaryVariable = generateTemporaryVariable(this@BaseFirBuilder.baseSession, source, tempName, argument.convert())
             statements += temporaryVariable
             val resultName = Name.special("<unary-result>")
-            val resultInitializer = FirFunctionCallImpl(source).apply {
-                this.calleeReference = FirSimpleNamedReference(baseExpression?.operationReference?.toFirSourceElement(), callName, null)
-                this.explicitReceiver = generateResolvedAccessExpression(source, temporaryVariable)
+            val resultInitializer = buildFunctionCall {
+                source = baseSource
+                calleeReference = buildSimpleNamedReference {
+                    source = baseExpression?.operationReference?.toFirSourceElement()
+                    name = callName
+                }
+                explicitReceiver = generateResolvedAccessExpression(source, temporaryVariable)
             }
-            val resultVar = generateTemporaryVariable(this@BaseFirBuilder.session, source, resultName, resultInitializer)
+            val resultVar = generateTemporaryVariable(this@BaseFirBuilder.baseSession, source, resultName, resultInitializer)
             val assignment = argument.generateAssignment(
                 source,
                 if (prefix && argument.elementType != REFERENCE_EXPRESSION)
@@ -394,7 +412,7 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
         }
     }
 
-    private fun FirModifiableQualifiedAccess.initializeLValue(
+    private fun FirQualifiedAccessBuilder.initializeLValue(
         left: T?,
         convertQualified: T.() -> FirQualifiedAccess?
     ): FirReference {
@@ -402,10 +420,16 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
         if (left != null) {
             when (tokenType) {
                 REFERENCE_EXPRESSION -> {
-                    return FirSimpleNamedReference(left.getSourceOrNull(), left.getReferencedNameAsName(), null)
+                    return buildSimpleNamedReference {
+                        source = left.getSourceOrNull()
+                        name = left.getReferencedNameAsName()
+                    }
                 }
                 THIS_EXPRESSION -> {
-                    return FirExplicitThisReference(left.getSourceOrNull(), left.getLabelName())
+                    return buildExplicitThisReference {
+                        source = left.getSourceOrNull()
+                        labelName = left.getLabelName()
+                    }
                 }
                 DOT_QUALIFIED_EXPRESSION, SAFE_ACCESS_EXPRESSION -> {
                     val firMemberAccess = left.convertQualified()
@@ -414,10 +438,10 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                         safe = firMemberAccess.safe
                         firMemberAccess.calleeReference
                     } else {
-                        FirErrorNamedReferenceImpl(
-                            left.getSourceOrNull(),
-                            FirSimpleDiagnostic("Unsupported qualified LValue: ${left.asText}", DiagnosticKind.Syntax)
-                        )
+                        buildErrorNamedReference {
+                            source = left.getSourceOrNull()
+                            diagnostic = FirSimpleDiagnostic("Unsupported qualified LValue: ${left.asText}", DiagnosticKind.Syntax)
+                        }
                     }
                 }
                 PARENTHESIZED -> {
@@ -425,62 +449,178 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                 }
             }
         }
-        return FirErrorNamedReferenceImpl(
-            left.getSourceOrNull(), FirSimpleDiagnostic("Unsupported LValue: $tokenType", DiagnosticKind.Syntax)
-        )
+        return buildErrorNamedReference {
+            source = left.getSourceOrNull()
+            diagnostic = FirSimpleDiagnostic("Unsupported LValue: $tokenType", DiagnosticKind.Syntax)
+        }
     }
 
     fun T?.generateAssignment(
-        source: FirSourceElement?,
+        baseSource: FirSourceElement?,
         value: FirExpression,
         operation: FirOperation,
         convert: T.() -> FirExpression
     ): FirStatement {
         val tokenType = this?.elementType
         if (tokenType == PARENTHESIZED) {
-            return this!!.getExpressionInParentheses().generateAssignment(source, value, operation, convert)
+            return this!!.getExpressionInParentheses().generateAssignment(baseSource, value, operation, convert)
         }
         if (tokenType == ARRAY_ACCESS_EXPRESSION) {
-            val firArrayAccess = this!!.convert() as FirFunctionCallImpl
-            val arraySet = if (operation != FirOperation.ASSIGN) {
-                FirArraySetCallImpl(source, value, operation).apply {
-                    indexes += firArrayAccess.arguments
-                }
-            } else {
-                return firArrayAccess.apply {
-                    calleeReference = FirSimpleNamedReference(source, OperatorNameConventions.SET, null)
-                    arguments += value
-                }
+            if (operation == FirOperation.ASSIGN) {
+                context.arraySetArgument[this!!] = value
+            }
+            val firArrayAccess = this!!.convert() as FirFunctionCall
+            if (operation == FirOperation.ASSIGN) {
+                return firArrayAccess
+            }
+            val arraySetCallBuilder = FirArraySetCallBuilder().apply {
+                source = baseSource
+                rValue = value
+                this.operation = operation
+                indexes += firArrayAccess.arguments
             }
             val arrayExpression = this.getChildNodeByType(REFERENCE_EXPRESSION)
             if (arrayExpression != null) {
-                return arraySet.apply {
-                    lValue = initializeLValue(arrayExpression) { convert() as? FirQualifiedAccess }
-                }
+                return arraySetCallBuilder.apply {
+                    calleeReference = initializeLValue(arrayExpression) { convert() as? FirQualifiedAccess }
+                }.build()
             }
             val psiArrayExpression = firArrayAccess.explicitReceiver?.psi
-            return FirBlockImpl(psiArrayExpression?.toFirSourceElement()).apply {
+            return buildBlock {
+                source = psiArrayExpression?.toFirSourceElement()
                 val name = Name.special("<array-set>")
                 statements += generateTemporaryVariable(
-                    this@BaseFirBuilder.session, this@generateAssignment.getSourceOrNull(), name, firArrayAccess.explicitReceiver!!
+                    this@BaseFirBuilder.baseSession, this@generateAssignment.getSourceOrNull(), name, firArrayAccess.explicitReceiver!!
                 )
-                statements += arraySet.apply { lValue = FirSimpleNamedReference(psiArrayExpression?.toFirSourceElement(), name, null) }
+                statements += arraySetCallBuilder.apply {
+                    calleeReference = buildSimpleNamedReference {
+                        source = psiArrayExpression?.toFirSourceElement()
+                        this.name = name
+                    }
+                }.build()
             }
         }
 
         if (operation in FirOperation.ASSIGNMENTS && operation != FirOperation.ASSIGN) {
-            return FirOperatorCallImpl(source, operation).apply {
+            return buildOperatorCall {
+                source = baseSource
+                this.operation = operation
                 // TODO: take good psi
                 arguments += this@generateAssignment?.convert() ?:
-                        FirErrorExpressionImpl(
-                            null, FirSimpleDiagnostic("Unsupported left value of assignment: ${source?.psi?.text}", DiagnosticKind.Syntax)
-                        )
+                        buildErrorExpression {
+                            source = null
+                            diagnostic = FirSimpleDiagnostic("Unsupported left value of assignment: ${baseSource?.psi?.text}", DiagnosticKind.Syntax)
+                        }
                 arguments += value
             }
         }
         require(operation == FirOperation.ASSIGN)
-        return FirVariableAssignmentImpl(source, false, value).apply {
-            lValue = initializeLValue(this@generateAssignment) { convert() as? FirQualifiedAccess }
+        return buildVariableAssignment {
+            source = baseSource
+            safe = false
+            rValue = value
+            calleeReference = initializeLValue(this@generateAssignment) { convert() as? FirQualifiedAccess }
         }
     }
+
+    fun List<Pair<T, FirProperty>>.generateComponentFunctions(
+        session: FirSession, firClassBuilder: AbstractFirRegularClassBuilder, packageFqName: FqName, classFqName: FqName,
+        firPrimaryConstructor: FirConstructor,
+    ) {
+        var componentIndex = 1
+        for ((sourceNode, firProperty) in this) {
+            if (!firProperty.isVal && !firProperty.isVar) continue
+            val name = Name.identifier("component$componentIndex")
+            componentIndex++
+            val parameterSource = sourceNode?.toFirSourceElement()
+            val target = FirFunctionTarget(labelName = null, isLambda = false)
+            val componentFunction = buildSimpleFunction {
+                source = parameterSource
+                this.session = session
+                returnTypeRef = buildImplicitTypeRef {
+                    source = parameterSource
+                }
+                receiverTypeRef = null
+                this.name = name
+                this.status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.FINAL)
+                this.symbol = FirNamedFunctionSymbol(CallableId(packageFqName, classFqName, name))
+
+                val returnExpression = buildReturnExpression {
+                    source = parameterSource
+                    result = buildQualifiedAccessExpression {
+                        source = parameterSource
+                        dispatchReceiver = buildThisReceiverExpression {
+                            calleeReference = buildImplicitThisReference {
+                                boundSymbol = firClassBuilder.symbol
+                            }
+                            typeRef = firPrimaryConstructor.returnTypeRef
+                        }
+                        calleeReference = buildResolvedNamedReference {
+                            source = parameterSource
+                            this.name = firProperty.name
+                            resolvedSymbol = firProperty.symbol
+                        }
+                    }
+                    this.target = target
+                }
+                body = buildSingleExpressionBlock(returnExpression)
+            }.also {
+                target.bind(it)
+            }
+            firClassBuilder.addDeclaration(componentFunction)
+        }
+    }
+
+    private val copyName = Name.identifier("copy")
+
+    fun List<Pair<T, FirProperty>>.generateCopyFunction(
+        session: FirSession,
+        classOrObject: KtClassOrObject?,
+        classBuilder: AbstractFirRegularClassBuilder,
+        packageFqName: FqName,
+        classFqName: FqName,
+        firPrimaryConstructor: FirConstructor,
+    ) {
+        classBuilder.addDeclaration(
+            buildSimpleFunction {
+                source = classOrObject?.toFirSourceElement()
+                this.session = session
+                returnTypeRef = firPrimaryConstructor.returnTypeRef
+                name = copyName
+                status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.FINAL)
+                symbol = FirNamedFunctionSymbol(CallableId(packageFqName, classFqName, copyName))
+                for ((ktParameter, firProperty) in this@generateCopyFunction) {
+                    val propertyName = firProperty.name
+                    val parameterSource = ktParameter?.toFirSourceElement()
+                    valueParameters += buildValueParameter {
+                        source = parameterSource
+                        this.session = session
+                        returnTypeRef = firProperty.returnTypeRef
+                        name = propertyName
+                        symbol = FirVariableSymbol(propertyName)
+                        defaultValue = buildQualifiedAccessExpression {
+                            source = parameterSource
+                            dispatchReceiver = buildThisReceiverExpression {
+                                calleeReference = buildImplicitThisReference {
+                                    boundSymbol = classBuilder.symbol
+                                }
+                                typeRef = firPrimaryConstructor.returnTypeRef
+                            }
+                            calleeReference = buildResolvedNamedReference {
+                                source = parameterSource
+                                this.name = propertyName
+                                resolvedSymbol = firProperty.symbol
+                            }
+                        }
+                        isCrossinline = false
+                        isNoinline = false
+                        isVararg = false
+                    }
+                }
+
+                body = buildEmptyExpressionBlock()
+            },
+        )
+    }
+
 }

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/Context.kt

@@ -5,20 +5,22 @@
 
 package org.jetbrains.kotlin.fir.builder
 
+import org.jetbrains.kotlin.fir.FirFunctionTarget
 import org.jetbrains.kotlin.fir.FirLabel
-import org.jetbrains.kotlin.fir.declarations.FirFunction
-import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
-import org.jetbrains.kotlin.fir.expressions.FirLoop
+import org.jetbrains.kotlin.fir.FirLoopTarget
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.builder.FirFunctionCallBuilder
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
-class Context {
+class Context<T> {
     lateinit var packageFqName: FqName
     var className: FqName = FqName.ROOT
-    val currentClassId get() = ClassId(packageFqName, className, firFunctions.isNotEmpty())
+    val currentClassId get() = ClassId(packageFqName, className, firFunctionTargets.isNotEmpty())
 
-    val firFunctions = mutableListOf<FirFunction<*>>()
-    val firFunctionCalls = mutableListOf<FirFunctionCall>()
+    val firFunctionTargets = mutableListOf<FirFunctionTarget>()
+    val firFunctionCalls = mutableListOf<FirFunctionCallBuilder>()
     val firLabels = mutableListOf<FirLabel>()
-    val firLoops = mutableListOf<FirLoop>()
+    val firLoopTargets = mutableListOf<FirLoopTarget>()
+    val arraySetArgument = mutableMapOf<T, FirExpression>()
 }

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt

@@ -9,25 +9,37 @@ import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirVariable
-import org.jetbrains.kotlin.fir.declarations.impl.*
+import org.jetbrains.kotlin.fir.declarations.builder.FirPropertyBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.buildProperty
+import org.jetbrains.kotlin.fir.declarations.builder.buildPropertyAccessor
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.*
-import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
-import org.jetbrains.kotlin.fir.references.impl.FirDelegateFieldReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
+import org.jetbrains.kotlin.fir.expressions.builder.*
+import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
+import org.jetbrains.kotlin.fir.expressions.impl.buildSingleExpressionBlock
+import org.jetbrains.kotlin.fir.references.builder.buildDelegateFieldReference
+import org.jetbrains.kotlin.fir.references.builder.buildExplicitThisReference
+import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
+import org.jetbrains.kotlin.fir.references.builder.buildSimpleNamedReference
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
+import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.ConeStarProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.FirUserTypeRef
-import org.jetbrains.kotlin.fir.types.impl.*
+import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildTypeProjectionWithVariance
+import org.jetbrains.kotlin.fir.types.builder.buildUserTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitKPropertyTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirQualifierPartImpl
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
@@ -135,55 +147,68 @@ fun IElementType.toFirOperation(): FirOperation =
     }
 
 fun FirExpression.generateNotNullOrOther(
-    session: FirSession, other: FirExpression, caseId: String, baseSource: FirSourceElement?
+    session: FirSession, other: FirExpression, caseId: String, baseSource: FirSourceElement?,
 ): FirWhenExpression {
     val subjectName = Name.special("<$caseId>")
     val subjectVariable = generateTemporaryVariable(session, baseSource, subjectName, this)
     val subject = FirWhenSubject()
-    val subjectExpression = FirWhenSubjectExpressionImpl(baseSource, subject)
-    return FirWhenExpressionImpl(
-        baseSource, this, subjectVariable
-    ).apply {
-        subject.bind(this)
-        branches += FirWhenBranchImpl(
-            baseSource,
-            FirOperatorCallImpl(baseSource, FirOperation.EQ).apply {
+    val subjectExpression = buildWhenSubjectExpression {
+        source = baseSource
+        whenSubject = subject
+    }
+
+    return buildWhenExpression {
+        source = baseSource
+        this.subject = this@generateNotNullOrOther
+        this.subjectVariable = subjectVariable
+        branches += buildWhenBranch {
+            source = baseSource
+            condition = buildOperatorCall {
+                source = baseSource
+                operation = FirOperation.EQ
                 arguments += subjectExpression
-                arguments += FirConstExpressionImpl(baseSource, FirConstKind.Null, null)
-            },
-            FirSingleExpressionBlock(other)
-        )
-        branches += FirWhenBranchImpl(
-            other.source, FirElseIfTrueCondition(baseSource),
-            FirSingleExpressionBlock(
-                generateResolvedAccessExpression(baseSource, subjectVariable)
-            )
-        )
+                arguments += buildConstExpression(baseSource, FirConstKind.Null, null)
+            }
+            result = buildSingleExpressionBlock(other)
+        }
+        branches += buildWhenBranch {
+            source = other.source
+            condition = buildElseIfTrueCondition {
+                source = baseSource
+            }
+            result = buildSingleExpressionBlock(generateResolvedAccessExpression(baseSource, subjectVariable))
+        }
+    }.also {
+        subject.bind(it)
     }
 }
 
 fun FirExpression.generateLazyLogicalOperation(
-    other: FirExpression, isAnd: Boolean, baseSource: FirSourceElement?
+    other: FirExpression, isAnd: Boolean, baseSource: FirSourceElement?,
 ): FirBinaryLogicExpression {
-    val kind = if (isAnd)
-        LogicOperationKind.AND
-    else
-        LogicOperationKind.OR
-    return FirBinaryLogicExpressionImpl(baseSource, this, other, kind)
+    return buildBinaryLogicExpression {
+        source = baseSource
+        leftOperand = this@generateLazyLogicalOperation
+        rightOperand = other
+        kind = if (isAnd) LogicOperationKind.AND else LogicOperationKind.OR
+    }
 }
 
 internal fun KtWhenCondition.toFirWhenCondition(
     subject: FirWhenSubject,
     convert: KtExpression?.(String) -> FirExpression,
-    toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef
+    toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef,
 ): FirExpression {
-    val firSubjectExpression = FirWhenSubjectExpressionImpl(this.toFirSourceElement(), subject)
+    val baseSource = this.toFirSourceElement()
+    val firSubjectExpression = buildWhenSubjectExpression {
+        source = baseSource
+        whenSubject = subject
+    }
     return when (this) {
         is KtWhenConditionWithExpression -> {
-            FirOperatorCallImpl(
-                expression?.toFirSourceElement(),
-                FirOperation.EQ
-            ).apply {
+            buildOperatorCall {
+                source = expression?.toFirSourceElement()
+                operation = FirOperation.EQ
                 arguments += firSubjectExpression
                 arguments += expression.convert("No expression in condition with expression")
             }
@@ -193,16 +218,15 @@ internal fun KtWhenCondition.toFirWhenCondition(
             firRange.generateContainsOperation(firSubjectExpression, isNegated, rangeExpression, operationReference)
         }
         is KtWhenConditionIsPattern -> {
-            FirTypeOperatorCallImpl(
-                typeReference?.toFirSourceElement(),
-                if (isNegated) FirOperation.NOT_IS else FirOperation.IS,
-                typeReference.toFirOrErrorTypeRef()
-            ).apply {
+            buildTypeOperatorCall {
+                source = typeReference?.toFirSourceElement()
+                operation = if (isNegated) FirOperation.NOT_IS else FirOperation.IS
+                conversionTypeRef = typeReference.toFirOrErrorTypeRef()
                 arguments += firSubjectExpression
             }
         }
         else -> {
-            FirErrorExpressionImpl(this.toFirSourceElement(), FirSimpleDiagnostic("Unsupported when condition: ${this.javaClass}", DiagnosticKind.Syntax))
+            buildErrorExpression(baseSource, FirSimpleDiagnostic("Unsupported when condition: ${this.javaClass}", DiagnosticKind.Syntax))
         }
     }
 }
@@ -211,7 +235,7 @@ internal fun Array<KtWhenCondition>.toFirWhenCondition(
     baseSource: FirSourceElement?,
     subject: FirWhenSubject,
     convert: KtExpression?.(String) -> FirExpression,
-    toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef
+    toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef,
 ): FirExpression {
     var firCondition: FirExpression? = null
     for (condition in this) {
@@ -219,7 +243,7 @@ internal fun Array<KtWhenCondition>.toFirWhenCondition(
         firCondition = when (firCondition) {
             null -> firConditionElement
             else -> firCondition.generateLazyLogicalOperation(
-                firConditionElement, false, baseSource
+                firConditionElement, false, baseSource,
             )
         }
     }
@@ -230,30 +254,47 @@ fun FirExpression.generateContainsOperation(
     argument: FirExpression,
     inverted: Boolean,
     base: KtExpression?,
-    operationReference: KtOperationReferenceExpression?
+    operationReference: KtOperationReferenceExpression?,
 ): FirFunctionCall {
     val baseSource = base?.toFirSourceElement()
     val operationReferenceSource = operationReference?.toFirSourceElement()
-    val containsCall = FirFunctionCallImpl(baseSource).apply {
-        calleeReference = FirSimpleNamedReference(operationReferenceSource, OperatorNameConventions.CONTAINS, null)
+    val containsCall = buildFunctionCall {
+        source = baseSource
+        calleeReference = buildSimpleNamedReference {
+            source = operationReferenceSource
+            name = OperatorNameConventions.CONTAINS
+        }
         explicitReceiver = this@generateContainsOperation
         arguments += argument
     }
     if (!inverted) return containsCall
-    return FirFunctionCallImpl(baseSource).apply {
-        calleeReference = FirSimpleNamedReference(operationReferenceSource, OperatorNameConventions.NOT, null)
+    return buildFunctionCall {
+        source = baseSource
+        calleeReference = buildSimpleNamedReference {
+            source = operationReferenceSource
+            name = OperatorNameConventions.NOT
+        }
         explicitReceiver = containsCall
     }
 }
 
 fun generateAccessExpression(source: FirSourceElement?, name: Name): FirQualifiedAccessExpression =
-    FirQualifiedAccessExpressionImpl(source).apply {
-        calleeReference = FirSimpleNamedReference(source, name, null)
+    buildQualifiedAccessExpression {
+        this.source = source
+        calleeReference = buildSimpleNamedReference {
+            this.source = source
+            this.name = name
+        }
     }
 
 fun generateResolvedAccessExpression(source: FirSourceElement?, variable: FirVariable<*>): FirQualifiedAccessExpression =
-    FirQualifiedAccessExpressionImpl(source).apply {
-        calleeReference = FirResolvedNamedReferenceImpl(source, variable.name, variable.symbol)
+    buildQualifiedAccessExpression {
+        this.source = source
+        calleeReference = buildResolvedNamedReference {
+            this.source = source
+            name = variable.name
+            resolvedSymbol = variable.symbol
+        }
     }
 
 internal fun generateDestructuringBlock(
@@ -261,142 +302,165 @@ internal fun generateDestructuringBlock(
     multiDeclaration: KtDestructuringDeclaration,
     container: FirVariable<*>,
     tmpVariable: Boolean,
-    extractAnnotationsTo: KtAnnotated.(FirAbstractAnnotatedElement) -> Unit,
-    toFirOrImplicitTypeRef: KtTypeReference?.() -> FirTypeRef
+    extractAnnotationsTo: KtAnnotated.(FirAnnotationContainerBuilder) -> Unit,
+    toFirOrImplicitTypeRef: KtTypeReference?.() -> FirTypeRef,
 ): FirExpression {
-    return FirBlockImpl(multiDeclaration.toFirSourceElement()).apply {
+    return buildBlock {
+        source = multiDeclaration.toFirSourceElement()
         if (tmpVariable) {
             statements += container
         }
         val isVar = multiDeclaration.isVar
         for ((index, entry) in multiDeclaration.entries.withIndex()) {
             val entrySource = entry.toFirSourceElement()
-            statements += FirPropertyImpl(
-                entrySource,
-                session,
-                entry.typeReference.toFirOrImplicitTypeRef(),
-                null,
-                entry.nameAsSafeName,
-                FirComponentCallImpl(entrySource, generateResolvedAccessExpression(entrySource, container), index + 1),
-                null,
-                isVar,
-                FirPropertySymbol(entry.nameAsSafeName), // TODO?
-                true,
-                FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
-            ).apply {
+            val name = entry.nameAsSafeName
+            statements += buildProperty {
+                source = entrySource
+                this.session = session
+                returnTypeRef = entry.typeReference.toFirOrImplicitTypeRef()
+                this.name = name
+                initializer = buildComponentCall {
+                    source = entrySource
+                    explicitReceiver = generateResolvedAccessExpression(entrySource, container)
+                    componentIndex = index + 1
+                }
+                this.isVar = isVar
+                isLocal = true
+                status = FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
+                symbol = FirPropertySymbol(name)
                 entry.extractAnnotationsTo(this)
-                symbol.bind(this)
             }
         }
     }
 }
 
 fun generateTemporaryVariable(
-    session: FirSession, source: FirSourceElement?, name: Name, initializer: FirExpression, typeRef: FirTypeRef? = null
+    session: FirSession, source: FirSourceElement?, name: Name, initializer: FirExpression, typeRef: FirTypeRef? = null,
 ): FirVariable<*> =
-    FirPropertyImpl(
-        source,
-        session,
-        typeRef ?: FirImplicitTypeRefImpl(source),
-        null,
-        name,
-        initializer,
-        null,
-        false,
-        FirPropertySymbol(name),
-        true,
-        FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
-    ).apply {
-        symbol.bind(this)
+    buildProperty {
+        this.source = source
+        this.session = session
+        returnTypeRef = typeRef ?: buildImplicitTypeRef {
+            this.source = source
+        }
+        this.name = name
+        this.initializer = initializer
+        symbol = FirPropertySymbol(name)
+        isVar = false
+        isLocal = true
+        status = FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
     }
 
 fun generateTemporaryVariable(
-    session: FirSession, source: FirSourceElement?, specialName: String, initializer: FirExpression
+    session: FirSession, source: FirSourceElement?, specialName: String, initializer: FirExpression,
 ): FirVariable<*> = generateTemporaryVariable(session, source, Name.special("<$specialName>"), initializer)
 
-fun FirModifiableVariable<*>.generateAccessorsByDelegate(
+fun FirPropertyBuilder.generateAccessorsByDelegate(
+    delegateBuilder: FirWrappedDelegateExpressionBuilder?,
     session: FirSession,
     member: Boolean,
     extension: Boolean,
     stubMode: Boolean,
     receiver: FirExpression?
+
 ) {
-    val variable = this as FirVariable<*>
-    val delegateFieldSymbol = delegateFieldSymbol ?: return
-    val delegate = delegate as? FirWrappedDelegateExpressionImpl ?: return
-    fun delegateAccess() = FirQualifiedAccessExpressionImpl(null).apply {
-        calleeReference = FirDelegateFieldReferenceImpl(null, null, delegateFieldSymbol)
+    if (delegateBuilder == null) return
+    val delegateFieldSymbol = FirDelegateFieldSymbol<FirProperty>(symbol.callableId).also {
+        this.delegateFieldSymbol = it
+    }
+    fun delegateAccess() = buildQualifiedAccessExpression {
+        source = null
+        calleeReference = buildDelegateFieldReference {
+            resolvedSymbol = delegateFieldSymbol
+        }
     }
 
     fun thisRef(): FirExpression =
-        when {
-            member || extension -> FirQualifiedAccessExpressionImpl(null).apply {
-                calleeReference = FirExplicitThisReference(null, null)
-            }
-            else -> FirConstExpressionImpl(null, FirConstKind.Null, null)
+        if (member || extension) buildQualifiedAccessExpression {
+            source = null
+            calleeReference = buildExplicitThisReference {}
         }
+        else buildConstExpression(null, FirConstKind.Null, null)
 
-    fun propertyRef() = FirCallableReferenceAccessImpl(null).apply {
-        calleeReference = FirResolvedNamedReferenceImpl(null, variable.name, variable.symbol)
+    fun propertyRef() = buildCallableReferenceAccess {
+        source = null
+        calleeReference = buildResolvedNamedReference {
+            source = null
+            name = this@generateAccessorsByDelegate.name
+            resolvedSymbol = this@generateAccessorsByDelegate.symbol
+        }
         typeRef = FirImplicitKPropertyTypeRef(null, ConeStarProjection)
     }
 
-    delegate.delegateProvider = if (stubMode) FirExpressionStub(null) else FirFunctionCallImpl(null).apply {
+    delegateBuilder.delegateProvider = if (stubMode) buildExpressionStub() else buildFunctionCall {
         explicitReceiver = receiver
-        calleeReference = FirSimpleNamedReference(null, PROVIDE_DELEGATE, null)
+        calleeReference = buildSimpleNamedReference {
+            source = null
+            name = PROVIDE_DELEGATE
+        }
         arguments += thisRef()
         arguments += propertyRef()
     }
+    delegate = delegateBuilder.build()
     if (stubMode) return
     if (getter == null || getter is FirDefaultPropertyAccessor) {
-        getter = FirPropertyAccessorImpl(
-            null,
-            session,
-            FirImplicitTypeRefImpl(null),
-            FirPropertyAccessorSymbol(),
-            true,
-            FirDeclarationStatusImpl(Visibilities.UNKNOWN, Modality.FINAL)
-        ).apply Accessor@{
+        val returnTarget = FirFunctionTarget(null, isLambda = false)
+        getter = buildPropertyAccessor {
+            this.session = session
+            returnTypeRef = buildImplicitTypeRef()
+            isGetter = true
+            status = FirDeclarationStatusImpl(Visibilities.UNKNOWN, Modality.FINAL)
+            symbol = FirPropertyAccessorSymbol()
+
             body = FirSingleExpressionBlock(
-                FirReturnExpressionImpl(
-                    null,
-                    FirFunctionCallImpl(null).apply {
+                buildReturnExpression {
+                    result = buildFunctionCall {
+                        source = null
                         explicitReceiver = delegateAccess()
-                        calleeReference = FirSimpleNamedReference(null, GET_VALUE, null)
+                        calleeReference = buildSimpleNamedReference {
+                            source = null
+                            name = GET_VALUE
+                        }
                         arguments += thisRef()
                         arguments += propertyRef()
                     }
-                ).apply {
-                    target = FirFunctionTarget(null)
-                    target.bind(this@Accessor)
+                    target = returnTarget
                 }
             )
+        }.also {
+            returnTarget.bind(it)
         }
     }
-    if (variable.isVar && (setter == null || setter is FirDefaultPropertyAccessor)) {
-        setter = FirPropertyAccessorImpl(
-            null,
-            session,
-            session.builtinTypes.unitType,
-            FirPropertyAccessorSymbol(),
-            false,
-            FirDeclarationStatusImpl(Visibilities.UNKNOWN, Modality.FINAL)
-        ).apply {
-            val parameter = FirValueParameterImpl(
-                null, session, FirImplicitTypeRefImpl(null),
-                DELEGATED_SETTER_PARAM, FirVariableSymbol(name),
-                defaultValue = null, isCrossinline = false,
-                isNoinline = false, isVararg = false
-            )
+    if (isVar && (setter == null || setter is FirDefaultPropertyAccessor)) {
+        setter = buildPropertyAccessor {
+            this.session = session
+            returnTypeRef = session.builtinTypes.unitType
+            isGetter = false
+            status = FirDeclarationStatusImpl(Visibilities.UNKNOWN, Modality.FINAL)
+            val parameter = buildValueParameter {
+                this.session = session
+                returnTypeRef = buildImplicitTypeRef()
+                name = DELEGATED_SETTER_PARAM
+                symbol = FirVariableSymbol(this@generateAccessorsByDelegate.name)
+                isCrossinline = false
+                isNoinline = false
+                isVararg = false
+            }
             valueParameters += parameter
+            symbol = FirPropertyAccessorSymbol()
             body = FirSingleExpressionBlock(
-                FirFunctionCallImpl(null).apply {
+                buildFunctionCall {
                     explicitReceiver = delegateAccess()
-                    calleeReference = FirSimpleNamedReference(null, SET_VALUE, null)
+                    calleeReference = buildSimpleNamedReference {
+                        name = SET_VALUE
+                    }
                     arguments += thisRef()
                     arguments += propertyRef()
-                    arguments += FirQualifiedAccessExpressionImpl(null).apply {
-                        calleeReference = FirResolvedNamedReferenceImpl(source, DELEGATED_SETTER_PARAM, parameter.symbol)
+                    arguments += buildQualifiedAccessExpression {
+                        calleeReference = buildResolvedNamedReference {
+                            name = DELEGATED_SETTER_PARAM
+                            resolvedSymbol = parameter.symbol
+                        }
                     }
                 }
             )
@@ -404,11 +468,15 @@ fun FirModifiableVariable<*>.generateAccessorsByDelegate(
     }
 }
 
-fun FirTypeRef.convertToArrayType(): FirUserTypeRef = FirUserTypeRefImpl(source, isMarkedNullable = false).apply {
+fun FirTypeRef.convertToArrayType(): FirUserTypeRef = buildUserTypeRef {
+    source = this@convertToArrayType.source
+    isMarkedNullable = false
     qualifier += FirQualifierPartImpl(StandardClassIds.Array.shortClassName).apply {
-        typeArguments += FirTypeProjectionWithVarianceImpl(
-            source, this@convertToArrayType, Variance.OUT_VARIANCE
-        )
+        typeArguments += buildTypeProjectionWithVariance {
+            source = this@convertToArrayType.source
+            typeRef = this@convertToArrayType
+            variance = Variance.OUT_VARIANCE
+        }
     }
 }
 

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt

@@ -1,111 +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.builder
-
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirFunctionTarget
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.addDeclaration
-import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableRegularClass
-import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
-import org.jetbrains.kotlin.fir.expressions.impl.*
-import org.jetbrains.kotlin.fir.references.impl.FirImplicitThisReference
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
-import org.jetbrains.kotlin.fir.symbols.CallableId
-import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
-import org.jetbrains.kotlin.fir.toFirSourceElement
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.KtClassOrObject
-import org.jetbrains.kotlin.psi.KtParameter
-
-fun List<Pair<KtParameter?, FirProperty>>.generateComponentFunctions(
-    session: FirSession, firClass: FirModifiableRegularClass, packageFqName: FqName, classFqName: FqName,
-    firPrimaryConstructor: FirConstructor
-) {
-    var componentIndex = 1
-    for ((ktParameter, firProperty) in this) {
-        if (!firProperty.isVal && !firProperty.isVar) continue
-        val name = Name.identifier("component$componentIndex")
-        componentIndex++
-        val symbol = FirNamedFunctionSymbol(CallableId(packageFqName, classFqName, name))
-        val status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.FINAL)
-        val parameterSource = ktParameter?.toFirSourceElement()
-        firClass.addDeclaration(
-            FirSimpleFunctionImpl(
-                parameterSource, session, FirImplicitTypeRefImpl(parameterSource),
-                null, status, name, symbol
-            ).apply {
-                val componentFunction = this
-                body = FirSingleExpressionBlock(
-                    FirReturnExpressionImpl(
-                        parameterSource,
-                        FirQualifiedAccessExpressionImpl(parameterSource).apply {
-                            val parameterName = firProperty.name
-                            dispatchReceiver = FirThisReceiverExpressionImpl(null, FirImplicitThisReference(firClass.symbol)).apply {
-                                typeRef = firPrimaryConstructor.returnTypeRef
-                            }
-                            calleeReference = FirResolvedNamedReferenceImpl(
-                                parameterSource,
-                                parameterName, firProperty.symbol
-                            )
-                        }
-                    ).apply {
-                        target = FirFunctionTarget(null)
-                        target.bind(componentFunction)
-                    }
-                )
-            }
-        )
-    }
-}
-
-private val copyName = Name.identifier("copy")
-
-fun List<Pair<KtParameter?, FirProperty>>.generateCopyFunction(
-    session: FirSession, classOrObject: KtClassOrObject?, firClass: FirModifiableRegularClass, packageFqName: FqName, classFqName: FqName,
-    firPrimaryConstructor: FirConstructor
-) {
-    val symbol = FirNamedFunctionSymbol(CallableId(packageFqName, classFqName, copyName))
-    val status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.FINAL)
-    firClass.addDeclaration(
-        FirSimpleFunctionImpl(
-            classOrObject?.toFirSourceElement(),
-            session,
-            firPrimaryConstructor.returnTypeRef,
-            null,
-            status,
-            copyName,
-            symbol
-        ).apply {
-            for ((ktParameter, firProperty) in this@generateCopyFunction) {
-                val name = firProperty.name
-                val parameterSource = ktParameter?.toFirSourceElement()
-                valueParameters += FirValueParameterImpl(
-                    parameterSource, session, firProperty.returnTypeRef,
-                    name,
-                    FirVariableSymbol(name),
-                    FirQualifiedAccessExpressionImpl(parameterSource).apply {
-                        dispatchReceiver = FirThisReceiverExpressionImpl(null, FirImplicitThisReference(firClass.symbol)).apply {
-                            typeRef = firPrimaryConstructor.returnTypeRef
-                        }
-                        calleeReference = FirResolvedNamedReferenceImpl(parameterSource, name, firProperty.symbol)
-                    },
-                    isCrossinline = false, isNoinline = false, isVararg = false
-                )
-            }
-
-            body = FirEmptyExpressionBlock()
-        }
-    )
-}

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

@@ -22,6 +22,8 @@ import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
+import org.jetbrains.kotlin.fir.references.impl.FirEmptyControlFlowGraphReference
+import org.jetbrains.kotlin.fir.references.impl.FirStubReference
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.isExtensionFunctionAnnotationCall
@@ -161,7 +163,8 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
 
 private fun throwTwiceVisitingError(element: FirElement) {
     if (element is FirTypeRef || element is FirNoReceiverExpression || element is FirTypeParameter ||
-        element is FirEmptyContractDescription || element.isExtensionFunctionAnnotation
+        element is FirEmptyContractDescription || element is FirEmptyControlFlowGraphReference ||
+        element is FirStubReference || element.isExtensionFunctionAnnotation
     ) {
         return
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/CopyUtils.kt

@@ -9,22 +9,20 @@ import org.jetbrains.kotlin.contracts.description.InvocationKind
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.declarations.impl.FirAnonymousFunctionImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
+import org.jetbrains.kotlin.fir.declarations.builder.buildAnonymousFunction
+import org.jetbrains.kotlin.fir.declarations.builder.buildTypeParameter
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirCheckNotNullCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirTryExpressionImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirWhenExpressionImpl
+import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.scopes.impl.FirIntegerOperatorCall
+import org.jetbrains.kotlin.fir.scopes.impl.FirIntegerOperatorCallBuilder
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 
 fun FirFunctionCall.copy(
     annotations: List<FirAnnotationCall> = this.annotations,
@@ -38,21 +36,27 @@ fun FirFunctionCall.copy(
     typeArguments: List<FirTypeProjection> = this.typeArguments,
     resultType: FirTypeRef = this.typeRef
 ): FirFunctionCall {
-    return if (this is FirIntegerOperatorCall) {
-        FirIntegerOperatorCall(source)
+    val builder = if (this is FirIntegerOperatorCall) {
+        FirIntegerOperatorCallBuilder().apply {
+            this.calleeReference = calleeReference
+        }
     } else {
-        FirFunctionCallImpl(source)
-    }.apply {
+        FirFunctionCallBuilder().apply {
+            this.calleeReference = calleeReference
+        }
+    }
+    builder.apply {
+        this.source = source
         this.safe = safe
         this.annotations.addAll(annotations)
         this.arguments.addAll(arguments)
-        this.calleeReference = calleeReference
         this.explicitReceiver = explicitReceiver
         this.dispatchReceiver = dispatchReceiver
         this.extensionReceiver = extensionReceiver
         this.typeArguments.addAll(typeArguments)
         this.typeRef = resultType
     }
+    return (builder as FirCallBuilder).build() as FirFunctionCall
 }
 
 fun FirAnonymousFunction.copy(
@@ -68,7 +72,13 @@ fun FirAnonymousFunction.copy(
     controlFlowGraphReference: FirControlFlowGraphReference = this.controlFlowGraphReference,
     invocationKind: InvocationKind? = this.invocationKind
 ): FirAnonymousFunction {
-    return FirAnonymousFunctionImpl(source, session, returnTypeRef, receiverTypeRef, symbol, isLambda).apply {
+    return buildAnonymousFunction {
+        this.source = source
+        this.session = session
+        this.returnTypeRef = returnTypeRef
+        this.receiverTypeRef = receiverTypeRef
+        symbol = this@copy.symbol
+        isLambda = this@copy.isLambda
         this.valueParameters.addAll(valueParameters)
         this.body = body
         this.annotations.addAll(annotations)
@@ -83,7 +93,9 @@ fun FirAnonymousFunction.copy(
 fun FirTypeRef.resolvedTypeFromPrototype(
     type: ConeKotlinType
 ): FirResolvedTypeRef {
-    return FirResolvedTypeRefImpl(source, type).apply {
+    return buildResolvedTypeRef {
+        source = this@resolvedTypeFromPrototype.source
+        this.type = type
         annotations += this@resolvedTypeFromPrototype.annotations
     }
 }
@@ -91,10 +103,14 @@ fun FirTypeRef.resolvedTypeFromPrototype(
 fun FirTypeParameter.copy(
     bounds: List<FirTypeRef> = this.bounds,
     annotations: List<FirAnnotationCall> = this.annotations
-): FirTypeParameterImpl {
-    return FirTypeParameterImpl(
-        source, session, name, symbol, variance, isReified
-    ).apply {
+): FirTypeParameter {
+    return buildTypeParameter {
+        source = this@copy.source
+        session = this@copy.session
+        name = this@copy.name
+        symbol = this@copy.symbol
+        variance = this@copy.variance
+        isReified = this@copy.isReified
         this.bounds += bounds
         this.annotations += annotations
     }
@@ -104,10 +120,13 @@ fun FirWhenExpression.copy(
     resultType: FirTypeRef = this.typeRef,
     calleeReference: FirReference = this.calleeReference,
     annotations: List<FirAnnotationCall> = this.annotations
-): FirWhenExpressionImpl = FirWhenExpressionImpl(source, subject, subjectVariable).apply {
+): FirWhenExpression = buildWhenExpression {
+    source = this@copy.source
+    subject = this@copy.subject
+    subjectVariable = this@copy.subjectVariable
     this.calleeReference = calleeReference
-    this@apply.branches.addAll(this@copy.branches)
-    this.typeRef = resultType
+    branches += this@copy.branches
+    typeRef = resultType
     this.annotations += annotations
 }
 
@@ -115,10 +134,13 @@ fun FirTryExpression.copy(
     resultType: FirTypeRef = this.typeRef,
     calleeReference: FirReference = this.calleeReference,
     annotations: List<FirAnnotationCall> = this.annotations
-): FirTryExpressionImpl = FirTryExpressionImpl(source, tryBlock, finallyBlock).apply {
+): FirTryExpression = buildTryExpression {
+    source = this@copy.source
+    tryBlock = this@copy.tryBlock
+    finallyBlock = this@copy.finallyBlock
     this.calleeReference = calleeReference
-    this@apply.catches.addAll(this@copy.catches)
-    this.typeRef = resultType
+    catches += this@copy.catches
+    typeRef = resultType
     this.annotations += annotations
 }
 
@@ -126,9 +148,10 @@ fun FirCheckNotNullCall.copy(
     resultType: FirTypeRef = this.typeRef,
     calleeReference: FirReference = this.calleeReference,
     annotations: List<FirAnnotationCall> = this.annotations
-): FirCheckNotNullCallImpl = FirCheckNotNullCallImpl(source).apply {
+): FirCheckNotNullCall = buildCheckNotNullCall {
+    source = this@copy.source
     this.calleeReference = calleeReference
-    this@apply.arguments.addAll(this@copy.arguments)
+    arguments += this@copy.arguments
     this.typeRef = resultType
     this.annotations += annotations
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt

@@ -8,16 +8,16 @@ package org.jetbrains.kotlin.fir
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub
-import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedQualifierImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedReifiedParameterReferenceImpl
+import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub
+import org.jetbrains.kotlin.fir.expressions.builder.buildResolvedQualifier
+import org.jetbrains.kotlin.fir.expressions.builder.buildResolvedReifiedParameterReference
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.FirSuperReference
-import org.jetbrains.kotlin.fir.references.impl.FirBackingFieldReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
+import org.jetbrains.kotlin.fir.references.builder.buildBackingFieldReference
+import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
+import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.*
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilder
 import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
@@ -46,7 +46,7 @@ class FirCallResolver(
     topLevelScopes: List<FirScope>,
     localScopes: List<FirLocalScope>,
     override val implicitReceiverStack: ImplicitReceiverStack,
-    private val qualifiedResolver: FirQualifiedNameResolver
+    private val qualifiedResolver: FirQualifiedNameResolver,
 ) : BodyResolveComponents by components {
 
     private lateinit var transformer: FirExpressionsResolveTransformer
@@ -58,7 +58,7 @@ class FirCallResolver(
     private val towerResolver = FirTowerResolver(
         returnTypeCalculator, this, resolutionStageRunner,
         topLevelScopes = topLevelScopes.asReversed(),
-        localScopes = localScopes.asReversed()
+        localScopes = localScopes.asReversed(),
     )
 
     private val conflictResolver =
@@ -86,7 +86,7 @@ class FirCallResolver(
             functionCall.calleeReference,
             functionCall.calleeReference.name,
             result.candidates,
-            result.applicability
+            result.applicability,
         )
 
         val resultExpression = functionCall.transformCalleeReference(StoreNameReference, nameReference)
@@ -99,7 +99,7 @@ class FirCallResolver(
                 dispatchReceiver = candidate.dispatchReceiverExpression(),
                 extensionReceiver = candidate.extensionReceiverExpression(),
                 arguments = candidate.callInfo.arguments,
-                safe = candidate.callInfo.isSafeCall
+                safe = candidate.callInfo.isSafeCall,
             )
         } else {
             resultExpression
@@ -112,7 +112,7 @@ class FirCallResolver(
     }
 
     private data class ResolutionResult(
-        val info: CallInfo, val applicability: CandidateApplicability, val candidates: Collection<Candidate>
+        val info: CallInfo, val applicability: CandidateApplicability, val candidates: Collection<Candidate>,
     )
 
     private fun collectCandidates(functionCall: FirFunctionCall): ResolutionResult {
@@ -129,12 +129,12 @@ class FirCallResolver(
             typeArguments,
             session,
             file,
-            transformer.components.implicitReceiverStack
+            transformer.components.implicitReceiverStack,
         )
         towerResolver.reset()
         val result = towerResolver.runResolver(
             implicitReceiverStack.receiversAsReversed(),
-            info
+            info,
         )
         val bestCandidates = result.bestCandidates()
         val reducedCandidates = if (result.currentApplicability < CandidateApplicability.SYNTHETIC_RESOLVED) {
@@ -168,12 +168,12 @@ class FirCallResolver(
             emptyList(),
             session,
             file,
-            transformer.components.implicitReceiverStack
+            transformer.components.implicitReceiverStack,
         )
         towerResolver.reset()
         val result = towerResolver.runResolver(
             implicitReceiverStack.receiversAsReversed(),
-            info
+            info,
         )
 
         val bestCandidates = result.bestCandidates()
@@ -189,7 +189,7 @@ class FirCallResolver(
             callee,
             callee.name,
             reducedCandidates,
-            result.currentApplicability
+            result.currentApplicability,
         )
 
         if (qualifiedAccess.explicitReceiver == null) {
@@ -214,10 +214,13 @@ class FirCallResolver(
         when {
             referencedSymbol is FirClassLikeSymbol<*> -> {
                 val classId = referencedSymbol.classId
-                return FirResolvedQualifierImpl(
-                    nameReference.source, classId.packageFqName, classId.relativeClassName, safe = false
-                ).apply {
+                return buildResolvedQualifier {
+                    source = nameReference.source
+                    packageFqName = classId.packageFqName
+                    relativeClassFqName = classId.relativeClassName
+                    safe = false
                     typeArguments.addAll(qualifiedAccess.typeArguments)
+                }.apply {
                     resultType = if (classId.isLocal) {
                         typeForQualifierByDeclaration(referencedSymbol.fir, resultType, session)
                             ?: session.builtinTypes.unitType
@@ -227,8 +230,10 @@ class FirCallResolver(
                 }
             }
             referencedSymbol is FirTypeParameterSymbol && referencedSymbol.fir.isReified -> {
-                return FirResolvedReifiedParameterReferenceImpl(nameReference.source, referencedSymbol).apply {
-                    resultType = typeForReifiedParameterReference(this)
+                return buildResolvedReifiedParameterReference {
+                    source = nameReference.source
+                    symbol = referencedSymbol
+                    typeRef = typeForReifiedParameterReference(this)
                 }
             }
         }
@@ -246,7 +251,7 @@ class FirCallResolver(
 
     fun resolveCallableReference(
         constraintSystemBuilder: ConstraintSystemBuilder,
-        resolvedCallableReferenceAtom: ResolvedCallableReferenceAtom
+        resolvedCallableReferenceAtom: ResolvedCallableReferenceAtom,
     ): Boolean {
         val callableReferenceAccess = resolvedCallableReferenceAtom.reference
         val lhs = resolvedCallableReferenceAtom.lhs
@@ -255,14 +260,14 @@ class FirCallResolver(
 
         val info = createCallableReferencesInfoForLHS(
             callableReferenceAccess, lhs,
-            expectedType, constraintSystemBuilder
+            expectedType, constraintSystemBuilder,
         )
         // No reset here!
         val result = towerResolver.runResolver(
             implicitReceiverStack.receiversAsReversed(),
             info,
             collector = CandidateCollector(this, resolutionStageRunner),
-            manager = TowerResolveManager(towerResolver)
+            manager = TowerResolveManager(towerResolver),
         )
         val bestCandidates = result.bestCandidates()
         val noSuccessfulCandidates = result.currentApplicability < CandidateApplicability.SYNTHETIC_RESOLVED
@@ -298,7 +303,7 @@ class FirCallResolver(
     fun resolveDelegatingConstructorCall(
         delegatedConstructorCall: FirDelegatedConstructorCall,
         symbol: FirClassSymbol<*>,
-        typeArguments: List<FirTypeProjection>
+        typeArguments: List<FirTypeProjection>,
     ): FirDelegatedConstructorCall? {
         val scope = symbol.fir.unsubstitutedScope(session, scopeSession)
         val className = symbol.classId.shortClassName
@@ -311,7 +316,7 @@ class FirCallResolver(
             typeArguments = typeArguments,
             session,
             file,
-            implicitReceiverStack
+            implicitReceiverStack,
         )
         val candidateFactory = CandidateFactory(this, callInfo)
         val candidates = mutableListOf<Candidate>()
@@ -325,7 +330,7 @@ class FirCallResolver(
     }
 
     private fun <T> selectCandidateFromGivenCandidates(
-        call: T, name: Name, candidates: Collection<Candidate>
+        call: T, name: Name, candidates: Collection<Candidate>,
     ): T where T : FirResolvable, T : FirCall {
         val result = CandidateCollector(this, resolutionStageRunner)
         candidates.forEach { result.consumeCandidate(TowerGroup.Start, it) }
@@ -340,7 +345,7 @@ class FirCallResolver(
             call.calleeReference,
             name,
             reducedCandidates,
-            result.currentApplicability
+            result.currentApplicability,
         )
 
         return call.transformCalleeReference(StoreNameReference, nameReference) as T
@@ -350,7 +355,7 @@ class FirCallResolver(
         callableReferenceAccess: FirCallableReferenceAccess,
         lhs: DoubleColonLHS?,
         expectedType: ConeKotlinType?,
-        outerConstraintSystemBuilder: ConstraintSystemBuilder?
+        outerConstraintSystemBuilder: ConstraintSystemBuilder?,
     ): CallInfo {
         return CallInfo(
             CallKind.CallableReference,
@@ -366,9 +371,12 @@ class FirCallResolver(
             expectedType,
             outerConstraintSystemBuilder,
             lhs,
-            stubReceiver = if (lhs !is DoubleColonLHS.Type) null else FirExpressionStub(callableReferenceAccess.source).apply {
-                replaceTypeRef(FirResolvedTypeRefImpl(null, lhs.type))
-            }
+            stubReceiver = if (lhs !is DoubleColonLHS.Type) null else buildExpressionStub {
+                source = callableReferenceAccess.source
+                typeRef = buildResolvedTypeRef {
+                    type = lhs.type
+                }
+            },
         )
     }
 
@@ -376,40 +384,54 @@ class FirCallResolver(
         reference: FirReference,
         name: Name,
         candidates: Collection<Candidate>,
-        applicability: CandidateApplicability
+        applicability: CandidateApplicability,
     ): FirNamedReference {
         val source = reference.source
         return when {
-            candidates.isEmpty() -> FirErrorNamedReferenceImpl(
-                source, FirUnresolvedNameError(name)
-            )
+            candidates.isEmpty() -> buildErrorNamedReference {
+                this.source = source
+                diagnostic = FirUnresolvedNameError(name)
+            }
             applicability < CandidateApplicability.SYNTHETIC_RESOLVED -> {
-                FirErrorNamedReferenceImpl(
-                    source,
-                    FirInapplicableCandidateError(applicability, candidates.map {
-                        FirInapplicableCandidateError.CandidateInfo(
-                            it.symbol,
-                            if (it.systemInitialized) it.system.diagnostics else emptyList()
-                        )
-                    })
-                )
+                buildErrorNamedReference {
+                    this.source = source
+                    diagnostic = FirInapplicableCandidateError(
+                        applicability,
+                        candidates.map {
+                            FirInapplicableCandidateError.CandidateInfo(
+                                it.symbol,
+                                if (it.systemInitialized) it.system.diagnostics else emptyList(),
+                            )
+                        },
+                    )
+                }
             }
             candidates.size == 1 -> {
                 val candidate = candidates.single()
                 val coneSymbol = candidate.symbol
                 when {
-                    coneSymbol is FirBackingFieldSymbol -> FirBackingFieldReferenceImpl(source, null, coneSymbol)
+                    coneSymbol is FirBackingFieldSymbol -> buildBackingFieldReference {
+                        this.source = source
+                        resolvedSymbol = coneSymbol
+                    }
+
                     coneSymbol is FirVariableSymbol && (
                             coneSymbol !is FirPropertySymbol ||
                                     (coneSymbol.phasedFir() as FirMemberDeclaration).typeParameters.isEmpty()
-                            ) ->
-                        FirResolvedNamedReferenceImpl(source, name, coneSymbol)
+                            )
+                    -> buildResolvedNamedReference {
+                        this.source = source
+                        this.name = name
+                        resolvedSymbol = coneSymbol
+                    }
+
                     else -> FirNamedReferenceWithCandidate(source, name, candidate)
                 }
             }
-            else -> FirErrorNamedReferenceImpl(
-                source, FirAmbiguityError(name, candidates.map { it.symbol })
-            )
+            else -> buildErrorNamedReference {
+                this.source = source
+                diagnostic = FirAmbiguityError(name, candidates.map { it.symbol })
+            }
         }
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirQualifiedNameResolver.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
 import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedQualifierImpl
+import org.jetbrains.kotlin.fir.expressions.builder.buildResolvedQualifier
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
@@ -62,12 +62,14 @@ class FirQualifiedNameResolver(components: BodyResolveComponents) : BodyResolveC
 
         if (resolved != null) {
             qualifierPartsToDrop = qualifierParts.size - 1
-            return FirResolvedQualifierImpl(
-                source,
-                resolved.packageFqName,
-                resolved.relativeClassFqName,
+            return buildResolvedQualifier {
+                this.source = source
+                packageFqName = resolved.packageFqName
+                relativeClassFqName = resolved.relativeClassFqName
                 safe = false
-            ).apply { resultType = typeForQualifier(this) }
+            }.apply {
+                resultType = typeForQualifier(this)
+            }
         }
 
         return null

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt

@@ -13,19 +13,19 @@ import org.jetbrains.kotlin.fir.declarations.collectEnumEntries
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirConstKind
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.impl.*
-import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
+import org.jetbrains.kotlin.fir.expressions.builder.*
+import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
+import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedSymbolError
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
-import org.jetbrains.kotlin.fir.expressions.FirConstKind
+import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.ProtoBuf.Annotation.Argument.Value.Type.*
 import org.jetbrains.kotlin.metadata.deserialization.Flags
@@ -87,21 +87,21 @@ abstract class AbstractAnnotationDeserializer(
                     val name = nameResolver.getName(it.nameId)
                     val parameter = parameterByName[name] ?: return@mapNotNull null
                     val value = resolveValue(parameter.returnTypeRef, it.value, nameResolver) ?: return@mapNotNull null
-                    FirNamedArgumentExpressionImpl(
-                        null, value, false, name
-                    )
+                    buildNamedArgumentExpression {
+                        expression = value
+                        isSpread = false
+                        this.name = name
+                    }
                 }
             }
         }
 
-        return FirAnnotationCallImpl(
-            null, null,
-            symbol?.let {
-                FirResolvedTypeRefImpl(
-                    null, it.constructType(emptyList(), isNullable = false)
-                )
-            } ?: FirErrorTypeRefImpl(null, FirUnresolvedSymbolError(classId))
-        ).apply {
+        return buildAnnotationCall {
+            annotationTypeRef = symbol?.let {
+                buildResolvedTypeRef {
+                    type = it.constructType(emptyList(), isNullable = false)
+                }
+            } ?: buildErrorTypeRef { diagnostic =FirUnresolvedSymbolError(classId) }
             this.arguments += arguments
         }
     }
@@ -122,16 +122,17 @@ abstract class AbstractAnnotationDeserializer(
             BOOLEAN -> const(FirConstKind.Boolean, (value.intValue != 0L))
             STRING -> const(FirConstKind.String, nameResolver.getString(value.stringValue))
             ANNOTATION -> deserializeAnnotation(value.annotation, nameResolver)
-            CLASS -> FirGetClassCallImpl(null).apply {
+            CLASS -> buildGetClassCall {
                 val classId = nameResolver.getClassId(value.classId)
                 val lookupTag = ConeClassLikeLookupTagImpl(classId)
                 val referencedType = lookupTag.constructType(emptyArray(), isNullable = false)
-                arguments += FirClassReferenceExpressionImpl(
-                    null,
-                    FirResolvedTypeRefImpl(null, referencedType)
-                )
+                arguments += buildClassReferenceExpression {
+                    classTypeRef = buildResolvedTypeRef {
+                        type = referencedType
+                    }
+                }
             }
-            ENUM -> FirFunctionCallImpl(null).apply {
+            ENUM -> buildFunctionCall {
                 val classId = nameResolver.getClassId(value.classId)
                 val entryName = nameResolver.getName(value.enumValueId)
 
@@ -142,11 +143,13 @@ abstract class AbstractAnnotationDeserializer(
                 val enumEntries = firClass?.collectEnumEntries() ?: emptyList()
                 val enumEntrySymbol = enumEntries.find { it.name == entryName }
                 this.calleeReference = enumEntrySymbol?.let {
-                    FirResolvedNamedReferenceImpl(null, entryName, it.symbol)
-                } ?: FirErrorNamedReferenceImpl(
-                    null,
-                    FirSimpleDiagnostic("Strange deserialized enum value: $classId.$entryName", DiagnosticKind.DeserializationError)
-                )
+                    buildResolvedNamedReference {
+                        name = entryName
+                        resolvedSymbol = it.symbol
+                    }
+                } ?: buildErrorNamedReference {
+                    diagnostic = FirSimpleDiagnostic("Strange deserialized enum value: $classId.$entryName", DiagnosticKind.DeserializationError)
+                }
             }
 //            ARRAY -> {
 //                TODO: see AnnotationDeserializer
@@ -157,5 +160,5 @@ abstract class AbstractAnnotationDeserializer(
         return result
     }
 
-    private fun <T> const(kind: FirConstKind<T>, value: T) = FirConstExpressionImpl(null, kind, value)
+    private fun <T> const(kind: FirConstKind<T>, value: T) = buildConstExpression(null, kind, value)
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt

@@ -11,16 +11,16 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.calculateSAM
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.addDeclarations
-import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
+import org.jetbrains.kotlin.fir.declarations.builder.FirClassImplBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.FirSealedClassBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.buildEnumEntry
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirEnumEntryImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirSealedClassImpl
 import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.Flags
 import org.jetbrains.kotlin.metadata.deserialization.NameResolver
@@ -57,28 +57,15 @@ fun deserializeClassToSymbol(
         isInline = Flags.IS_INLINE_CLASS.get(classProto.flags)
     }
     val isSealed = modality == Modality.SEALED
-    val firClass = if (isSealed) {
-        FirSealedClassImpl(
-            null,
-            session,
-            status,
-            ProtoEnumFlags.classKind(kind),
-            scopeProvider,
-            classId.shortClassName,
-            symbol
-        )
-    } else {
-        FirClassImpl(
-            null,
-            session,
-            status,
-            ProtoEnumFlags.classKind(kind),
-            scopeProvider,
-            classId.shortClassName,
-            symbol
-        )
-    }
-    firClass.apply {
+    val classBuilder = if (isSealed) FirSealedClassBuilder() else FirClassImplBuilder()
+    classBuilder.apply {
+        this.session = session
+        name = classId.shortClassName
+        this.status = status
+        classKind = ProtoEnumFlags.classKind(kind)
+        this.scopeProvider = scopeProvider
+        this.symbol = symbol
+
         resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
         val context =
             parentContext?.childContext(
@@ -102,7 +89,7 @@ fun deserializeClassToSymbol(
 
         superTypesDeserialized.mapNotNullTo(superTypeRefs) {
             if (it == null) return@mapNotNullTo null
-            FirResolvedTypeRefImpl(null, it)
+            buildResolvedTypeRef { type = it }
         }
 
         addDeclarations(classProto.functionList.map(classDeserializer::loadFunction))
@@ -126,17 +113,14 @@ fun deserializeClassToSymbol(
                 val enumEntryName = nameResolver.getName(enumEntryProto.name)
 
                 val enumType = ConeClassLikeTypeImpl(symbol.toLookupTag(), emptyArray(), false)
-                val property = FirEnumEntryImpl(
-                    null,
-                    session,
-                    FirResolvedTypeRefImpl(null, enumType),
-                    enumEntryName,
-                    initializer = null,
-                    symbol = FirVariableSymbol(CallableId(classId, enumEntryName)),
-                    status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.FINAL).apply {
+                val property = buildEnumEntry {
+                    this.session = session
+                    returnTypeRef = buildResolvedTypeRef { type = enumType }
+                    name = enumEntryName
+                    this.symbol = FirVariableSymbol(CallableId(classId, enumEntryName))
+                    this.status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.FINAL).apply {
                         isStatic = true
                     }
-                ).apply {
                     resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
                 }
 
@@ -145,10 +129,10 @@ fun deserializeClassToSymbol(
         )
 
         if (isSealed) {
-            classProto.sealedSubclassFqNameList.mapTo((firClass as FirSealedClassImpl).inheritors) {
+            classProto.sealedSubclassFqNameList.mapTo((this as FirSealedClassBuilder).inheritors) {
                 ClassId.fromString(nameResolver.getQualifiedClassName(it))
             }
         }
+        calculateSAM()
     }
-    firClass.calculateSAM()
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirContractDeserializer.kt

@@ -7,8 +7,8 @@ package org.jetbrains.kotlin.fir.deserialization
 
 import org.jetbrains.kotlin.contracts.description.InvocationKind
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
+import org.jetbrains.kotlin.fir.contracts.builder.buildContractDescription
 import org.jetbrains.kotlin.fir.contracts.description.*
-import org.jetbrains.kotlin.fir.contracts.impl.FirContractDescriptionImpl
 import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.expressions.LogicOperationKind
@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 class FirContractDeserializer(private val c: FirDeserializationContext) {
     fun loadContract(proto: ProtoBuf.Contract, owner: FirContractDescriptionOwner): FirContractDescription? {
         val effects = proto.effectList.map { loadPossiblyConditionalEffect(it, owner) ?: return null }
-        return FirContractDescriptionImpl(null).apply {
-            this.effects.addAll(effects)
+        return buildContractDescription {
+            this.effects += effects
         }
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt

@@ -9,20 +9,22 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.builder.*
 import org.jetbrains.kotlin.fir.declarations.impl.*
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub
+import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 import org.jetbrains.kotlin.serialization.deserialization.getName
 
 class FirDeserializationContext(
@@ -131,59 +133,50 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
         val flags = proto.flags
         val name = c.nameResolver.getName(proto.name)
         val local = c.childContext(proto.typeParameterList)
-        val status = FirDeclarationStatusImpl(ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)), Modality.FINAL).apply {
-            isExpect = Flags.IS_EXPECT_CLASS.get(flags)
-            isActual = false
-        }
-        return FirTypeAliasImpl(
-            null,
-            c.session,
-            status,
-            name,
-            FirTypeAliasSymbol(ClassId(c.packageFqName, name)),
-            FirResolvedTypeRefImpl(
-                null,
-                local.typeDeserializer.type(proto.underlyingType(c.typeTable))
-            )
-        ).apply {
+        return buildTypeAlias {
+            session = c.session
+            this.name = name
+            status = FirDeclarationStatusImpl(ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)), Modality.FINAL).apply {
+                isExpect = Flags.IS_EXPECT_CLASS.get(flags)
+                isActual = false
+            }
+            symbol = FirTypeAliasSymbol(ClassId(c.packageFqName, name))
+            expandedTypeRef = buildResolvedTypeRef {
+                type = local.typeDeserializer.type(proto.underlyingType(c.typeTable))
+            }
             resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
             typeParameters += local.typeDeserializer.ownTypeParameters.map { it.fir }
         }
     }
 
-    fun loadProperty(proto: ProtoBuf.Property): FirProperty {
+    fun loadProperty(proto: ProtoBuf.Property, containerSource: DeserializedContainerSource? = null): FirProperty {
         val flags = if (proto.hasFlags()) proto.flags else loadOldFlags(proto.oldFlags)
         val callableName = c.nameResolver.getName(proto.name)
         val symbol = FirPropertySymbol(CallableId(c.packageFqName, c.relativeClassName, callableName))
         val local = c.childContext(proto.typeParameterList)
-        val returnTypeRef = proto.returnType(c.typeTable).toTypeRef(local)
 
         val getterFlags = if (proto.hasGetterFlags()) proto.getterFlags else flags
         val setterFlags = if (proto.hasSetterFlags()) proto.setterFlags else flags
         val isVar = Flags.IS_VAR.get(flags)
-        val status = FirDeclarationStatusImpl(
-            ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
-            ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
-        ).apply {
-            isExpect = Flags.IS_EXPECT_PROPERTY.get(flags)
-            isActual = false
-            isOverride = false
-            isConst = Flags.IS_CONST.get(flags)
-            isLateInit = Flags.IS_LATEINIT.get(flags)
-        }
-        return FirPropertyImpl(
-            null,
-            c.session,
-            returnTypeRef,
-            proto.receiverType(c.typeTable)?.toTypeRef(local),
-            callableName,
-            null,
-            null,
-            isVar,
-            symbol,
-            false,
-            status
-        ).apply {
+        return buildProperty {
+            session = c.session
+            returnTypeRef = proto.returnType(c.typeTable).toTypeRef(local)
+            receiverTypeRef = proto.receiverType(c.typeTable)?.toTypeRef(local)
+            name = callableName
+            this.isVar = isVar
+            this.symbol = symbol
+            isLocal = false
+            status = FirDeclarationStatusImpl(
+                ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+                ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
+            ).apply {
+                isExpect = Flags.IS_EXPECT_PROPERTY.get(flags)
+                isActual = false
+                isOverride = false
+                isConst = Flags.IS_CONST.get(flags)
+                isLateInit = Flags.IS_LATEINIT.get(flags)
+            }
+
             resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
             typeParameters += local.typeDeserializer.ownTypeParameters.map { it.fir }
             annotations += c.annotationDeserializer.loadPropertyAnnotations(proto, local.nameResolver)
@@ -191,10 +184,11 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             setter = if (isVar) {
                 FirDefaultPropertySetter(null, c.session, returnTypeRef, ProtoEnumFlags.visibility(Flags.VISIBILITY.get(setterFlags)))
             } else null
+            this.containerSource = containerSource
         }
     }
 
-    fun loadFunction(proto: ProtoBuf.Function): FirSimpleFunction {
+    fun loadFunction(proto: ProtoBuf.Function, containerSource: DeserializedContainerSource? = null): FirSimpleFunction {
         val flags = if (proto.hasFlags()) proto.flags else loadOldFlags(proto.oldFlags)
 
         val receiverAnnotations =
@@ -208,99 +202,83 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
         val callableName = c.nameResolver.getName(proto.name)
         val symbol = FirNamedFunctionSymbol(CallableId(c.packageFqName, c.relativeClassName, callableName))
         val local = c.childContext(proto.typeParameterList)
-        val status = FirDeclarationStatusImpl(
-            ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
-            ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
-        ).apply {
-            isExpect = Flags.IS_EXPECT_FUNCTION.get(flags)
-            isActual = false
-            isOverride = false
-            isOperator = Flags.IS_OPERATOR.get(flags)
-            isInfix = Flags.IS_INFIX.get(flags)
-            isInline = Flags.IS_INLINE.get(flags)
-            isTailRec = Flags.IS_TAILREC.get(flags)
-            isExternal = Flags.IS_EXTERNAL_FUNCTION.get(flags)
-            isSuspend = Flags.IS_SUSPEND.get(flags)
-        }
-
         // TODO: support contracts
 
-        val simpleFunction = FirSimpleFunctionImpl(
-            null,
-            c.session,
-            proto.returnType(local.typeTable).toTypeRef(local),
-            proto.receiverType(local.typeTable)?.toTypeRef(local),
-            status,
-            callableName,
-            symbol
-        ).apply {
+        val simpleFunction = buildSimpleFunction {
+            session = c.session
+            returnTypeRef = proto.returnType(local.typeTable).toTypeRef(local)
+            receiverTypeRef = proto.receiverType(local.typeTable)?.toTypeRef(local)
+            name = callableName
+            status = FirDeclarationStatusImpl(
+                ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+                ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
+            ).apply {
+                isExpect = Flags.IS_EXPECT_FUNCTION.get(flags)
+                isActual = false
+                isOverride = false
+                isOperator = Flags.IS_OPERATOR.get(flags)
+                isInfix = Flags.IS_INFIX.get(flags)
+                isInline = Flags.IS_INLINE.get(flags)
+                isTailRec = Flags.IS_TAILREC.get(flags)
+                isExternal = Flags.IS_EXTERNAL_FUNCTION.get(flags)
+                isSuspend = Flags.IS_SUSPEND.get(flags)
+            }
+            this.symbol = symbol
             resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
             typeParameters += local.typeDeserializer.ownTypeParameters.map { it.fir }
             valueParameters += local.memberDeserializer.valueParameters(proto.valueParameterList)
             annotations += local.annotationDeserializer.loadFunctionAnnotations(proto, local.nameResolver)
+            this.containerSource = containerSource
         }
         if (proto.hasContract()) {
             val contractDescription = contractDeserializer.loadContract(proto.contract, simpleFunction)
             if (contractDescription != null) {
-                simpleFunction.contractDescription = contractDescription
+                simpleFunction.replaceContractDescription(contractDescription)
             }
         }
         return simpleFunction
     }
 
-    fun loadConstructor(proto: ProtoBuf.Constructor, klass: FirRegularClass): FirConstructor {
+    fun loadConstructor(proto: ProtoBuf.Constructor, classBuilder: AbstractFirRegularClassBuilder): FirConstructor {
         val flags = proto.flags
         val relativeClassName = c.relativeClassName!!
         val symbol = FirConstructorSymbol(CallableId(c.packageFqName, relativeClassName, relativeClassName.shortName()))
         val local = c.childContext(emptyList())
         val isPrimary = !Flags.IS_SECONDARY.get(flags)
 
-        val typeParameters = klass.typeParameters
+        val typeParameters = classBuilder.typeParameters
 
-        val delegatedSelfType = FirResolvedTypeRefImpl(
-            null,
-            ConeClassLikeTypeImpl(
-                klass.symbol.toLookupTag(),
+        val delegatedSelfType = buildResolvedTypeRef {
+            type = ConeClassLikeTypeImpl(
+                classBuilder.symbol.toLookupTag(),
                 typeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) }.toTypedArray(),
                 false
             )
-        )
-
-        val status = FirDeclarationStatusImpl(ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)), Modality.FINAL).apply {
-            isExpect = Flags.IS_EXPECT_FUNCTION.get(flags)
-            isActual = false
-            isInner = klass.isInner
         }
+
         return if (isPrimary) {
-            FirPrimaryConstructorImpl(
-                null,
-                c.session,
-                delegatedSelfType,
-                null,
-                status,
-                symbol
-            )
+            FirPrimaryConstructorBuilder()
         } else {
-            FirConstructorImpl(
-                null,
-                c.session,
-                delegatedSelfType,
-                null,
-                status,
-                symbol
-            )
+            FirConstructorBuilder()
         }.apply {
+            session = c.session
+            returnTypeRef = delegatedSelfType
+            status = FirDeclarationStatusImpl(ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)), Modality.FINAL).apply {
+                isExpect = Flags.IS_EXPECT_FUNCTION.get(flags)
+                isActual = false
+                isInner = classBuilder.status.isInner
+            }
+            this.symbol = symbol
             resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
             this.typeParameters += typeParameters
             valueParameters += local.memberDeserializer.valueParameters(proto.valueParameterList)
             annotations += local.annotationDeserializer.loadConstructorAnnotations(proto, local.nameResolver)
-        }
-
+        }.build()
     }
 
     private fun defaultValue(flags: Int): FirExpression? {
         if (Flags.DECLARES_DEFAULT_VALUE.get(flags)) {
-            return FirExpressionStub(null)
+            return buildExpressionStub()
         }
         return null
     }
@@ -311,27 +289,23 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
         return valueParameters.map { proto ->
             val flags = if (proto.hasFlags()) proto.flags else 0
             val name = c.nameResolver.getName(proto.name)
-            FirValueParameterImpl(
-                null,
-                c.session,
-                proto.type(c.typeTable).toTypeRef(c),
-                name,
-                FirVariableSymbol(name),
-                defaultValue(flags),
-                isCrossinline = Flags.IS_CROSSINLINE.get(flags),
-                isNoinline = Flags.IS_NOINLINE.get(flags),
+            buildValueParameter {
+                session = c.session
+                returnTypeRef = proto.type(c.typeTable).toTypeRef(c)
+                this.name = name
+                symbol = FirVariableSymbol(name)
+                defaultValue = defaultValue(flags)
+                isCrossinline = Flags.IS_CROSSINLINE.get(flags)
+                isNoinline = Flags.IS_NOINLINE.get(flags)
                 isVararg = proto.varargElementType(c.typeTable) != null
-            ).apply {
                 annotations += c.annotationDeserializer.loadValueParameterAnnotations(proto, c.nameResolver)
             }
         }.toList()
     }
 
     private fun ProtoBuf.Type.toTypeRef(context: FirDeserializationContext): FirTypeRef {
-        val coneType = context.typeDeserializer.type(this)
-        return FirResolvedTypeRefImpl(
-            null, coneType
-        ).apply {
+        return buildResolvedTypeRef {
+            type = context.typeDeserializer.type(this@toTypeRef)
             annotations += context.annotationDeserializer.loadTypeAnnotations(this@toTypeRef, context.nameResolver)
         }
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.deserialization
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
 import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary
-import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
+import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder
 import org.jetbrains.kotlin.fir.resolve.toTypeProjection
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.ConeClassifierLookupTag
@@ -17,9 +17,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.*
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
@@ -35,6 +35,51 @@ class FirTypeDeserializer(
     typeParameterProtos: List<ProtoBuf.TypeParameter>,
     val parent: FirTypeDeserializer?
 ) {
+    private val typeParameterDescriptors: Map<Int, FirTypeParameterSymbol> = if (typeParameterProtos.isNotEmpty()) {
+        LinkedHashMap<Int, FirTypeParameterSymbol>()
+    } else {
+        mapOf()
+    }
+
+    private val typeParameterNames: Map<String, FirTypeParameterSymbol>
+
+    val ownTypeParameters: List<FirTypeParameterSymbol>
+        get() = typeParameterDescriptors.values.toList()
+
+    init {
+        if (typeParameterProtos.isNotEmpty()) {
+            typeParameterNames = mutableMapOf()
+            val result = typeParameterDescriptors as LinkedHashMap<Int, FirTypeParameterSymbol>
+            val builders = mutableListOf<FirTypeParameterBuilder>()
+            for (proto in typeParameterProtos) {
+                if (!proto.hasId()) continue
+                val name = nameResolver.getName(proto.name)
+                val symbol = FirTypeParameterSymbol().also {
+                    typeParameterNames[name.asString()] = it
+                }
+                builders += FirTypeParameterBuilder().apply {
+                    session = this@FirTypeDeserializer.session
+                    this.name = name
+                    this.symbol = symbol
+                    variance = proto.variance.convertVariance()
+                    isReified = proto.reified
+                }
+                result[proto.id] = symbol
+            }
+
+            for ((index, proto) in typeParameterProtos.withIndex()) {
+                val builder = builders[index]
+                builder.apply {
+                    proto.upperBoundList.mapTo(bounds) {
+                        buildResolvedTypeRef { type = type(it) }
+                    }
+                    addDefaultBoundIfNecessary()
+                }.build()
+            }
+        } else {
+            typeParameterNames = emptyMap()
+        }
+    }
 
     private fun computeClassifier(fqNameIndex: Int): ConeClassLikeLookupTag? {
         try {
@@ -47,7 +92,6 @@ class FirTypeDeserializer(
 
     fun type(proto: ProtoBuf.Type): ConeKotlinType {
         if (proto.hasFlexibleTypeCapabilitiesId()) {
-            val id = nameResolver.getString(proto.flexibleTypeCapabilitiesId)
             val lowerBound = simpleType(proto)
             val upperBound = simpleType(proto.flexibleUpperBound(typeTable)!!)
             return ConeFlexibleType(lowerBound!!, upperBound!!)
@@ -57,7 +101,6 @@ class FirTypeDeserializer(
         return simpleType(proto) ?: ConeKotlinErrorType("?!id:0")
     }
 
-
     private fun typeParameterSymbol(typeParameterId: Int): ConeTypeParameterLookupTag? =
         typeParameterDescriptors[typeParameterId]?.toLookupTag() ?: parent?.typeParameterSymbol(typeParameterId)
 
@@ -70,46 +113,6 @@ class FirTypeDeserializer(
         }
     }
 
-    private val typeParameterDescriptors: Map<Int, FirTypeParameterSymbol> =
-        if (typeParameterProtos.isEmpty()) {
-            mapOf()
-        } else {
-            val result = LinkedHashMap<Int, FirTypeParameterSymbol>()
-            for ((index, proto) in typeParameterProtos.withIndex()) {
-                if (!proto.hasId()) continue
-                val name = nameResolver.getName(proto.name)
-                val symbol = FirTypeParameterSymbol()
-                FirTypeParameterImpl(
-                    null,
-                    session,
-                    name,
-                    symbol,
-                    proto.variance.convertVariance(),
-                    proto.reified
-                )
-                result[proto.id] = symbol
-            }
-            result
-        }
-
-
-    init {
-        for ((index, proto) in typeParameterProtos.withIndex()) {
-            if (!proto.hasId()) continue
-            val symbol = typeParameterDescriptors[proto.id]!!
-            val declaration = symbol.fir as FirTypeParameterImpl
-            declaration.apply {
-                proto.upperBoundList.mapTo(bounds) {
-                    FirResolvedTypeRefImpl(null, type(it))
-                }
-                addDefaultBoundIfNecessary()
-            }
-        }
-    }
-
-    val ownTypeParameters: List<FirTypeParameterSymbol>
-        get() = typeParameterDescriptors.values.toList()
-
 
     fun FirClassLikeSymbol<*>.typeParameters(): List<FirTypeParameterSymbol> =
         (fir as? FirTypeParametersOwner)?.typeParameters?.map { it.symbol }.orEmpty()
@@ -146,9 +149,7 @@ class FirTypeDeserializer(
             proto.hasTypeParameter() -> typeParameterSymbol(proto.typeParameter)
             proto.hasTypeParameterName() -> {
                 val name = nameResolver.getString(proto.typeParameterName)
-
-                // TODO: Optimize
-                ownTypeParameters.find { it.name.asString() == name }?.toLookupTag()
+                typeParameterNames[name]?.toLookupTag()
             }
             else -> null
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -13,6 +13,8 @@ import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.FirStubDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.builder.FirResolvedQualifierBuilder
+import org.jetbrains.kotlin.fir.expressions.builder.FirResolvedReifiedParameterReferenceBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionWithSmartcastImpl
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
@@ -29,10 +31,10 @@ import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.AbstractStrictEqualityTypeChecker
 import org.jetbrains.kotlin.types.Variance
@@ -65,7 +67,7 @@ fun ConeClassLikeLookupTag.toSymbol(useSiteSession: FirSession): FirClassLikeSym
 
 fun ConeClassLikeType.fullyExpandedType(
     useSiteSession: FirSession,
-    expandedConeType: (FirTypeAlias) -> ConeClassLikeType? = FirTypeAlias::expandedConeType
+    expandedConeType: (FirTypeAlias) -> ConeClassLikeType? = FirTypeAlias::expandedConeType,
 ): ConeClassLikeType {
     if (this is ConeClassLikeTypeImpl) {
         val expandedTypeAndSession = cachedExpandedType
@@ -83,7 +85,7 @@ fun ConeClassLikeType.fullyExpandedType(
 
 private fun ConeClassLikeType.fullyExpandedTypeNoCache(
     useSiteSession: FirSession,
-    expandedConeType: (FirTypeAlias) -> ConeClassLikeType?
+    expandedConeType: (FirTypeAlias) -> ConeClassLikeType?,
 ): ConeClassLikeType {
     val directExpansionType = directExpansionType(useSiteSession, expandedConeType) ?: return this
     return directExpansionType.fullyExpandedType(useSiteSession, expandedConeType)
@@ -91,7 +93,7 @@ private fun ConeClassLikeType.fullyExpandedTypeNoCache(
 
 fun ConeClassLikeType.directExpansionType(
     useSiteSession: FirSession,
-    expandedConeType: (FirTypeAlias) -> ConeClassLikeType? = FirTypeAlias::expandedConeType
+    expandedConeType: (FirTypeAlias) -> ConeClassLikeType? = FirTypeAlias::expandedConeType,
 ): ConeClassLikeType? {
     val typeAlias = lookupTag
         .toSymbol(useSiteSession)
@@ -105,7 +107,7 @@ fun ConeClassLikeType.directExpansionType(
 private fun mapTypeAliasArguments(
     typeAlias: FirTypeAlias,
     abbreviatedType: ConeClassLikeType,
-    resultingType: ConeClassLikeType
+    resultingType: ConeClassLikeType,
 ): ConeKotlinType {
     val typeAliasMap = typeAlias.typeParameters.map { it.symbol }.zip(abbreviatedType.typeArguments).toMap()
 
@@ -141,7 +143,10 @@ fun ConeClassifierLookupTag.toSymbol(useSiteSession: FirSession): FirClassifierS
 
 fun ConeTypeParameterLookupTag.toSymbol(): FirTypeParameterSymbol = this.symbol as FirTypeParameterSymbol
 
-fun ConeClassLikeLookupTag.constructClassType(typeArguments: Array<out ConeKotlinTypeProjection>, isNullable: Boolean): ConeLookupTagBasedType {
+fun ConeClassLikeLookupTag.constructClassType(
+    typeArguments: Array<out ConeKotlinTypeProjection>,
+    isNullable: Boolean,
+): ConeLookupTagBasedType {
     return ConeClassLikeTypeImpl(this, typeArguments, isNullable)
 }
 
@@ -165,7 +170,7 @@ fun FirClassifierSymbol<*>.constructType(typeArguments: Array<ConeKotlinTypeProj
             ConeClassLikeTypeImpl(
                 this.toLookupTag(),
                 typeArguments = typeArguments,
-                isNullable = isNullable
+                isNullable = isNullable,
             )
         }
         else -> error("!")
@@ -178,7 +183,7 @@ fun FirClassifierSymbol<*>.constructType(parts: List<FirQualifierPart>, isNullab
 fun FirClassifierSymbol<*>.constructType(
     parts: List<FirQualifierPart>,
     isNullable: Boolean,
-    symbolOriginSession: FirSession
+    symbolOriginSession: FirSession,
 ): ConeKotlinType =
     constructType(parts.toTypeProjections(), isNullable)
         .also {
@@ -211,7 +216,7 @@ private fun List<FirQualifierPart>.toTypeProjections(): Array<ConeKotlinTypeProj
 fun coneFlexibleOrSimpleType(
     typeContext: ConeInferenceContext?,
     lowerBound: ConeKotlinType,
-    upperBound: ConeKotlinType
+    upperBound: ConeKotlinType,
 ): ConeKotlinType {
     if (lowerBound is ConeFlexibleType) {
         return coneFlexibleOrSimpleType(typeContext, lowerBound.lowerBound, upperBound)
@@ -296,14 +301,17 @@ fun FirFunction<*>.constructFunctionalTypeRef(session: FirSession): FirResolvedT
 
     val functionalType = createFunctionalType(parameters, receiverTypeRef?.coneTypeSafe(), rawReturnType)
 
-    return FirResolvedTypeRefImpl(source, functionalType)
+    return buildResolvedTypeRef {
+        source = this@constructFunctionalTypeRef.source
+        type = functionalType
+    }
 }
 
 fun createFunctionalType(
     parameters: List<ConeKotlinType>,
     receiverType: ConeKotlinType?,
     rawReturnType: ConeKotlinType,
-    isKFunctionType: Boolean = false
+    isKFunctionType: Boolean = false,
 ): ConeLookupTagBasedType {
     val receiverAndParameterTypes = listOfNotNull(receiverType) + parameters + listOf(rawReturnType)
 
@@ -315,7 +323,7 @@ fun createFunctionalType(
 fun createKPropertyType(
     receiverType: ConeKotlinType?,
     rawReturnType: ConeKotlinType,
-    isMutable: Boolean
+    isMutable: Boolean,
 ): ConeLookupTagBasedType {
     val arguments = if (receiverType != null) listOf(receiverType, rawReturnType) else listOf(rawReturnType)
     val classId = StandardClassIds.reflectByName("K${if (isMutable) "Mutable" else ""}Property${arguments.size - 1}")
@@ -327,7 +335,9 @@ fun BodyResolveComponents.typeForQualifier(resolvedQualifier: FirResolvedQualifi
     val resultType = resolvedQualifier.resultType
     if (classId != null) {
         val classSymbol = symbolProvider.getClassLikeSymbolByFqName(classId)
-            ?: return FirErrorTypeRefImpl(source = null, diagnostic = FirSimpleDiagnostic("No type for qualifier", DiagnosticKind.Other))
+            ?: return buildErrorTypeRef {
+                diagnostic = FirSimpleDiagnostic("No type for qualifier", DiagnosticKind.Other)
+            }
         val declaration = classSymbol.phasedFir
         if (declaration !is FirTypeAlias || resolvedQualifier.typeArguments.isEmpty()) {
             typeForQualifierByDeclaration(declaration, resultType, session)?.let { return it }
@@ -337,9 +347,9 @@ fun BodyResolveComponents.typeForQualifier(resolvedQualifier: FirResolvedQualifi
     return session.builtinTypes.unitType
 }
 
-internal fun typeForReifiedParameterReference(parameterReference: FirResolvedReifiedParameterReference): FirTypeRef {
-    val resultType = parameterReference.resultType
-    val typeParameterSymbol = parameterReference.symbol
+internal fun typeForReifiedParameterReference(parameterReferenceBuilder: FirResolvedReifiedParameterReferenceBuilder): FirTypeRef {
+    val resultType = parameterReferenceBuilder.typeRef
+    val typeParameterSymbol = parameterReferenceBuilder.symbol
     return resultType.resolvedTypeFromPrototype(typeParameterSymbol.constructType(emptyArray(), false))
 }
 
@@ -351,13 +361,13 @@ internal fun typeForQualifierByDeclaration(declaration: FirDeclaration, resultTy
     if (declaration is FirRegularClass) {
         if (declaration.classKind == ClassKind.OBJECT) {
             return resultType.resolvedTypeFromPrototype(
-                declaration.symbol.constructType(emptyArray(), false)
+                declaration.symbol.constructType(emptyArray(), false),
             )
         } else {
             val companionObject = declaration.companionObject
             if (companionObject != null) {
                 return resultType.resolvedTypeFromPrototype(
-                    companionObject.symbol.constructType(emptyArray(), false)
+                    companionObject.symbol.constructType(emptyArray(), false),
                 )
             }
         }
@@ -385,7 +395,10 @@ fun <T : FirResolvable> BodyResolveComponents.typeFromCallee(access: T): FirReso
 
     return when (val newCallee = access.calleeReference) {
         is FirErrorNamedReference ->
-            FirErrorTypeRefImpl(access.source, FirStubDiagnostic(newCallee.diagnostic))
+            buildErrorTypeRef {
+                source = access.source
+                diagnostic = FirStubDiagnostic(newCallee.diagnostic)
+            }
         is FirNamedReferenceWithCandidate -> {
             typeFromSymbol(newCallee.candidateSymbol, makeNullable)
         }
@@ -395,10 +408,16 @@ fun <T : FirResolvable> BodyResolveComponents.typeFromCallee(access: T): FirReso
         is FirThisReference -> {
             val labelName = newCallee.labelName
             val implicitReceiver = implicitReceiverStack[labelName]
-            FirResolvedTypeRefImpl(null, implicitReceiver?.type ?: ConeKotlinErrorType("Unresolved this@$labelName"))
+            buildResolvedTypeRef {
+                source = null
+                type = implicitReceiver?.type ?: ConeKotlinErrorType("Unresolved this@$labelName")
+            }
         }
         is FirSuperReference -> {
-            newCallee.superTypeRef as? FirResolvedTypeRef ?: FirErrorTypeRefImpl(newCallee.source, FirUnresolvedNameError(Name.identifier("super")))
+            newCallee.superTypeRef as? FirResolvedTypeRef ?: buildErrorTypeRef {
+                source = newCallee.source
+                diagnostic = FirUnresolvedNameError(Name.identifier("super"))
+            }
         }
         else -> error("Failed to extract type from: $newCallee")
     }
@@ -410,7 +429,7 @@ private fun BodyResolveComponents.typeFromSymbol(symbol: AbstractFirBasedSymbol<
             val returnType = returnTypeCalculator.tryCalculateReturnType(symbol.phasedFir)
             if (makeNullable) {
                 returnType.withReplacedConeType(
-                    returnType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NULLABLE, session.inferenceContext)
+                    returnType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NULLABLE, session.inferenceContext),
                 )
             } else {
                 returnType
@@ -419,9 +438,10 @@ private fun BodyResolveComponents.typeFromSymbol(symbol: AbstractFirBasedSymbol<
         is FirClassifierSymbol<*> -> {
             val fir = (symbol as? AbstractFirBasedSymbol<*>)?.phasedFir
             // TODO: unhack
-            FirResolvedTypeRefImpl(
-                null, symbol.constructType(emptyArray(), isNullable = false)
-            )
+            buildResolvedTypeRef {
+                source = null
+                type = symbol.constructType(emptyArray(), isNullable = false)
+            }
         }
         else -> error("WTF ! $symbol")
     }
@@ -434,7 +454,9 @@ fun BodyResolveComponents.transformQualifiedAccessUsingSmartcastInfo(qualifiedAc
     }
     val intersectedType = ConeTypeIntersector.intersectTypes(inferenceComponents.ctx as ConeInferenceContext, allTypes)
     // TODO: add check that intersectedType is not equal to original type
-    val intersectedTypeRef = FirResolvedTypeRefImpl(qualifiedAccessExpression.resultType.source, intersectedType).apply {
+    val intersectedTypeRef = buildResolvedTypeRef {
+        source = qualifiedAccessExpression.resultType.source
+        type = intersectedType
         annotations += qualifiedAccessExpression.resultType.annotations
     }
     return FirExpressionWithSmartcastImpl(qualifiedAccessExpression, intersectedTypeRef, typesFromSmartCast)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt

@@ -10,10 +10,10 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.inferenceContext
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticFunctionSymbol
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
@@ -25,9 +25,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance
@@ -43,7 +43,7 @@ val SAM_PARAMETER_NAME = Name.identifier("block")
 
 class FirSamResolverImpl(
     private val firSession: FirSession,
-    private val scopeSession: ScopeSession
+    private val scopeSession: ScopeSession,
 ) : FirSamResolver {
 
     private val resolvedFunctionType: MutableMap<FirRegularClass, Any> = mutableMapOf()
@@ -54,13 +54,14 @@ class FirSamResolverImpl(
             is ConeClassLikeType -> getFunctionTypeForPossibleSamType(type)
             is ConeFlexibleType -> ConeFlexibleType(
                 getFunctionTypeForPossibleSamType(type.lowerBound) ?: return null,
-                getFunctionTypeForPossibleSamType(type.upperBound) ?: return null
+                getFunctionTypeForPossibleSamType(type.upperBound) ?: return null,
             )
             is ConeClassErrorType, is ConeStubType -> null
             // TODO: support those types as well
             is ConeTypeParameterType, is ConeTypeVariableType,
             is ConeCapturedType, is ConeDefinitelyNotNullType, is ConeIntersectionType,
-            is ConeIntegerLiteralType -> null
+            is ConeIntegerLiteralType,
+            -> null
             // TODO: Thing of getting rid of this branch since ConeLookupTagBasedType should be a sealed class
             is ConeLookupTagBasedType -> null
         }
@@ -78,12 +79,14 @@ class FirSamResolverImpl(
             substitutorByMap(
                 firRegularClass.typeParameters
                     .map { it.symbol }
-                    .zip(type.typeArguments.map {
-                        (it as? ConeTypedProjection)?.type
-                            ?: firSession.builtinTypes.nullableAnyType.type
-                        //ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(StandardClassIds.Any), emptyArray(), isNullable = true)
-                    })
-                    .toMap()
+                    .zip(
+                        type.typeArguments.map {
+                            (it as? ConeTypedProjection)?.type
+                                ?: firSession.builtinTypes.nullableAnyType.type
+                            //ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(StandardClassIds.Any), emptyArray(), isNullable = true)
+                        },
+                    )
+                    .toMap(),
             )
 
         val result =
@@ -112,19 +115,18 @@ class FirSamResolverImpl(
             CallableId(
                 classId.packageFqName,
                 classId.relativeClassName.parent().takeIf { !it.isRoot },
-                classId.shortClassName
-            )
+                classId.shortClassName,
+            ),
         )
 
         val newTypeParameters = firRegularClass.typeParameters.map { typeParameter ->
-            FirTypeParameterImpl(
-                typeParameter.source,
-                firSession,
-                typeParameter.name,
-                FirTypeParameterSymbol(),
-                Variance.INVARIANT,
+            FirTypeParameterBuilder().apply {
+                source = typeParameter.source
+                session = firSession
+                name = typeParameter.name
+                this.symbol = FirTypeParameterSymbol()
+                variance = Variance.INVARIANT
                 isReified = false
-            ).apply {
                 annotations += typeParameter.annotations
             }
         }
@@ -136,59 +138,57 @@ class FirSamResolverImpl(
         val substitutor = substitutorByMap(
             firRegularClass.typeParameters
                 .map { it.symbol }
-                .zip(newTypeParameterTypes).toMap()
+                .zip(newTypeParameterTypes).toMap(),
         )
 
         for ((newTypeParameter, oldTypeParameter) in newTypeParameters.zip(firRegularClass.typeParameters)) {
             newTypeParameter.bounds += oldTypeParameter.bounds.mapNotNull { typeRef ->
-                FirResolvedTypeRefImpl(
-                    typeRef.source,
-                    substitutor.substituteOrSelf(typeRef.coneTypeSafe() ?: return@mapNotNull null)
-                )
+                buildResolvedTypeRef {
+                    source = typeRef.source
+                    type = substitutor.substituteOrSelf(typeRef.coneTypeSafe() ?: return@mapNotNull null)
+                }
             }
         }
 
         val substitutedFunctionType = substitutor.substituteOrSelf(functionType)
         val substitutedReturnType =
             ConeClassLikeTypeImpl(
-                firRegularClass.symbol.toLookupTag(), newTypeParameterTypes.toTypedArray(), isNullable = false
+                firRegularClass.symbol.toLookupTag(), newTypeParameterTypes.toTypedArray(), isNullable = false,
             )
 
-        val status = FirDeclarationStatusImpl(firRegularClass.visibility, Modality.FINAL).apply {
-            isExpect = firRegularClass.isExpect
-            isActual = firRegularClass.isActual
-            isOverride = false
-            isOperator = false
-            isInfix = false
-            isExternal = false
-            isInline = false
-            isSuspend = false
-            isTailRec = false
-        }
+        return buildSimpleFunction {
+            session = firSession
+            returnTypeRef = buildResolvedTypeRef {
+                source = null
+                type = substitutedReturnType
+            }
+            name = classId.shortClassName
+            status = FirDeclarationStatusImpl(firRegularClass.visibility, Modality.FINAL).apply {
+                isExpect = firRegularClass.isExpect
+                isActual = firRegularClass.isActual
+                isOverride = false
+                isOperator = false
+                isInfix = false
+                isExternal = false
+                isInline = false
+                isSuspend = false
+                isTailRec = false
+            }
+            this.symbol = symbol
+            valueParameters += buildValueParameter {
+                session = firSession
+                returnTypeRef = buildResolvedTypeRef {
+                    source = firRegularClass.source
+                    type = substitutedFunctionType
+                }
+                name = SAM_PARAMETER_NAME
+                this.symbol = FirVariableSymbol(SAM_PARAMETER_NAME)
+                isCrossinline = false
+                isNoinline = false
+                isVararg = false
+            }
 
-        return FirSimpleFunctionImpl(
-            null,
-            firSession,
-            FirResolvedTypeRefImpl(null, substitutedReturnType),
-            null,
-            status,
-            classId.shortClassName,
-            symbol
-        ).apply {
-            valueParameters += listOf(
-                FirValueParameterImpl(
-                    source,
-                    session,
-                    FirResolvedTypeRefImpl(firRegularClass.source, substitutedFunctionType),
-                    SAM_PARAMETER_NAME,
-                    FirVariableSymbol(SAM_PARAMETER_NAME),
-                    defaultValue = null,
-                    isCrossinline = false,
-                    isNoinline = false,
-                    isVararg = false
-                )
-            )
-            typeParameters += newTypeParameters
+            typeParameters += newTypeParameters.map { it.build() }
             resolvePhase = FirResolvePhase.BODY_RESOLVE
         }
     }
@@ -210,7 +210,7 @@ class FirSamResolverImpl(
 
 private fun FirRegularClass.getSingleAbstractMethodOrNull(
     session: FirSession,
-    scopeSession: ScopeSession
+    scopeSession: ScopeSession,
 ): FirSimpleFunction? {
     // TODO: restrict to Java interfaces
     if (classKind != ClassKind.INTERFACE || hasMoreThenOneAbstractFunctionOrHasAbstractProperty()) return null
@@ -247,7 +247,7 @@ private fun FirRegularClass.computeSamCandidateNames(session: FirSession): Set<N
 private fun FirRegularClass.findSingleAbstractMethodByNames(
     session: FirSession,
     scopeSession: ScopeSession,
-    samCandidateNames: Set<Name>
+    samCandidateNames: Set<Name>,
 ): FirSimpleFunction? {
     if (status.isNotSAM) return null
 
@@ -351,6 +351,6 @@ private fun FirSimpleFunction.getFunctionTypeForAbstractMethod(): ConeLookupTagB
 
     return createFunctionalType(
         parameterTypes, receiverType = null,
-        rawReturnType = returnTypeRef.coneTypeSafe() ?: ConeKotlinErrorType("No type for return type of $this")
+        rawReturnType = returnTypeRef.coneTypeSafe() ?: ConeKotlinErrorType("No type for return type of $this"),
     )
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.fir.resolve.calls
 import com.intellij.openapi.progress.ProcessCanceledException
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirConstructorImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
+import org.jetbrains.kotlin.fir.declarations.builder.buildConstructor
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
@@ -223,29 +223,28 @@ private fun prepareSubstitutingScopeForTypeAliasConstructors(
             expandedType,
             session
         ) factory@{ newReturnType, newParameterTypes, newTypeParameters ->
-            FirConstructorImpl(
-                source, session,
-                returnTypeRef.withReplacedConeType(newReturnType),
-                receiverTypeRef, status,
-                FirConstructorSymbol(symbol.callableId, overriddenSymbol = symbol)
-            ).apply {
+            buildConstructor {
+                source = this@factory.source
+                this.session = session
+                returnTypeRef = this@factory.returnTypeRef.withReplacedConeType(newReturnType)
+                receiverTypeRef = this@factory.receiverTypeRef
+                status = this@factory.status
+                symbol = FirConstructorSymbol(this@factory.symbol.callableId, overriddenSymbol = this@factory.symbol)
                 resolvePhase = this@factory.resolvePhase
                 valueParameters +=
                     this@factory.valueParameters.zip(
                         newParameterTypes
                     ) { valueParameter, newParameterType ->
-                        with(valueParameter) {
-                            FirValueParameterImpl(
-                                source,
-                                session,
-                                returnTypeRef.withReplacedConeType(newParameterType),
-                                name,
-                                FirVariableSymbol(valueParameter.symbol.callableId),
-                                defaultValue,
-                                isCrossinline,
-                                isNoinline,
-                                isVararg
-                            )
+                        buildValueParameter {
+                            source = valueParameter.source
+                            this.session = session
+                            returnTypeRef = valueParameter.returnTypeRef.withReplacedConeType(newParameterType)
+                            name = valueParameter.name
+                            symbol = FirVariableSymbol(valueParameter.symbol.callableId)
+                            defaultValue = valueParameter.defaultValue
+                            isCrossinline = valueParameter.isCrossinline
+                            isNoinline = valueParameter.isNoinline
+                            isVararg = valueParameter.isVararg
                         }
                     }
                 this.typeParameters += newTypeParameters

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirNamedReferenceWithCandidate.kt

@@ -5,11 +5,13 @@
 
 package org.jetbrains.kotlin.fir.resolve.calls
 
+import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 
+@UseExperimental(FirImplementationDetail::class)
 class FirNamedReferenceWithCandidate(
     source: FirSourceElement?,
     name: Name,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt

@@ -6,24 +6,30 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
+import org.jetbrains.kotlin.fir.declarations.expandedConeType
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.impl.FirThisReceiverExpressionImpl
-import org.jetbrains.kotlin.fir.references.impl.FirImplicitThisReference
+import org.jetbrains.kotlin.fir.expressions.builder.buildThisReceiverExpression
+import org.jetbrains.kotlin.fir.references.builder.buildImplicitThisReference
 import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.resolve.scope
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.impl.FirQualifierScope
+import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.ConeStarProjection
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
+import org.jetbrains.kotlin.name.ClassId
 
 interface Receiver {
     fun scope(useSiteSession: FirSession, scopeSession: ScopeSession): FirScope?
@@ -39,8 +45,13 @@ interface ReceiverValue : Receiver {
 }
 
 private fun receiverExpression(symbol: AbstractFirBasedSymbol<*>, type: ConeKotlinType): FirExpression =
-    FirThisReceiverExpressionImpl(null, FirImplicitThisReference(symbol)).apply {
-        typeRef = FirResolvedTypeRefImpl(null, type)
+    buildThisReceiverExpression {
+        calleeReference = buildImplicitThisReference {
+            boundSymbol = symbol
+        }
+        typeRef = buildResolvedTypeRef {
+            this.type = type
+        }
     }
 
 class ClassDispatchReceiverValue(klassSymbol: FirClassSymbol<*>) : ReceiverValue {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.fir.resolve.calls
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.impl.FirImportImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
+import org.jetbrains.kotlin.fir.declarations.builder.buildImport
+import org.jetbrains.kotlin.fir.declarations.builder.buildResolvedImport
 import org.jetbrains.kotlin.fir.declarations.isCompanion
 import org.jetbrains.kotlin.fir.declarations.isInner
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -89,11 +89,13 @@ class FirTowerResolver(
             listOf(
                 FirExplicitSimpleImportingScope(
                     listOf(
-                        FirResolvedImportImpl(
-                            FirImportImpl(source = null, importedFqName = FqName.topLevel(info.name), isAllUnder = false, aliasName = null),
-                            resolvedQualifier.packageFqName,
-                            relativeClassName = null
-                        )
+                        buildResolvedImport {
+                        delegate = buildImport {
+                             importedFqName = FqName.topLevel(info.name)
+                            isAllUnder = false
+                            }
+                        packageFqName = resolvedQualifier.packageFqName
+                        }
                     ), session, components.scopeSession
                 )
             )

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/PostponedArgumentsAnalyzer.kt

@@ -9,11 +9,11 @@ import org.jetbrains.kotlin.fir.FirCallResolver
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
+import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
 import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedReferenceError
 import org.jetbrains.kotlin.fir.resolve.transformers.StoreNameReference
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.resolve.calls.components.InferenceSession
 import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzer
 import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystemConstraintPosition
@@ -78,10 +78,10 @@ class PostponedArgumentsAnalyzer(
 
         val namedReference = when {
             candidate == null || applicability < CandidateApplicability.SYNTHETIC_RESOLVED ->
-                FirErrorNamedReferenceImpl(
-                    callableReferenceAccess.source,
-                    FirUnresolvedReferenceError(callableReferenceAccess.calleeReference.name)
-                )
+                buildErrorNamedReference {
+                    source = callableReferenceAccess.source
+                    diagnostic = FirUnresolvedReferenceError(callableReferenceAccess.calleeReference.name)
+                }
             else -> FirNamedReferenceWithCandidate(callableReferenceAccess.source, callableReferenceAccess.calleeReference.name, candidate)
         }
 
@@ -90,7 +90,7 @@ class PostponedArgumentsAnalyzer(
             namedReference
         ).apply {
             if (candidate != null) {
-                replaceTypeRef(FirResolvedTypeRefImpl(null, candidate.resultingTypeForCallableReference!!))
+                replaceTypeRef(buildResolvedTypeRef { type = candidate.resultingTypeForCallableReference!! })
             }
         }
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/QualifierReceiver.kt

@@ -7,9 +7,8 @@ package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.expandedConeType
-import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirSealedClassImpl
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
@@ -107,7 +106,7 @@ class QualifierReceiver(override val explicitReceiver: FirResolvedQualifier) : A
         val (classSymbol, callableScopes) = getClassSymbolWithCallableScopes(classId, useSiteSession, scopeSession)
         if (classSymbol != null) {
             val klass = classSymbol.fir
-            val classifierScope = if (klass is FirClassImpl || klass is FirSealedClassImpl) {
+            val classifierScope = if ((klass as? FirRegularClass)?.hasLazyNestedClassifiers == false) {
                 nestedClassifierScope(klass)
             } else {
                 useSiteSession.firSymbolProvider.getNestedClassifierScope(classId)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolverParts.kt

@@ -99,7 +99,8 @@ internal sealed class CheckReceivers : ResolutionStage() {
             val receiverType = (callable.receiverTypeRef as FirResolvedTypeRef?)?.type
             if (receiverType != null) return receiverType
             val returnTypeRef = callable.returnTypeRef as? FirResolvedTypeRef ?: return null
-            return returnTypeRef.type.receiverType(returnTypeRef, bodyResolveComponents.session)
+            if (!returnTypeRef.isExtensionFunctionType(bodyResolveComponents.session)) return null
+            return (returnTypeRef.type.typeArguments.firstOrNull() as? ConeTypedProjection)?.type
         }
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerResolveManager.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
-import org.jetbrains.kotlin.fir.expressions.impl.FirQualifiedAccessExpressionImpl
+import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessExpressionBuilder
 import org.jetbrains.kotlin.fir.resolve.constructClassType
 import org.jetbrains.kotlin.fir.resolve.transformQualifiedAccessUsingSmartcastInfo
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.firUnsafe
@@ -105,9 +105,9 @@ class TowerResolveManager internal constructor(private val towerResolver: FirTow
         val explicitReceiverKind: ExplicitReceiverKind,
         val group: TowerGroup
     ) {
-        private fun createExplicitReceiverForInvoke(candidate: Candidate): FirQualifiedAccessExpressionImpl {
+        private fun createExplicitReceiverForInvoke(candidate: Candidate): FirQualifiedAccessExpressionBuilder {
             val symbol = candidate.symbol as FirCallableSymbol<*>
-            return FirQualifiedAccessExpressionImpl(null).apply {
+            return FirQualifiedAccessExpressionBuilder().apply {
                 calleeReference = FirNamedReferenceWithCandidate(
                     null,
                     symbol.callableId.callableName,
@@ -184,7 +184,7 @@ class TowerResolveManager internal constructor(private val towerResolver: FirTow
                                     it.explicitReceiver = info.explicitReceiver
                                     it.safe = info.isSafeCall
                                 }
-                                towerResolver.components.transformQualifiedAccessUsingSmartcastInfo(it)
+                                towerResolver.components.transformQualifiedAccessUsingSmartcastInfo(it.build())
                             }
 
                             val invokeFunctionInfo =

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/VariableStorage.kt

@@ -6,15 +6,13 @@
 package org.jetbrains.kotlin.fir.resolve.dfa
 
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSymbolOwner
-import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirExpressionWithSmartcast
+import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
+import org.jetbrains.kotlin.fir.expressions.FirWhenSubjectExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
-import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.FirThisReference
-import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
-import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 
 @UseExperimental(DfaInternals::class)
 class VariableStorage {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/contracts/ConeConditionalEffectToFirVisitor.kt

@@ -8,10 +8,11 @@ package org.jetbrains.kotlin.fir.resolve.dfa.contracts
 import org.jetbrains.kotlin.fir.contracts.description.*
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.fir.expressions.FirConstKind
+import org.jetbrains.kotlin.fir.expressions.builder.*
+import org.jetbrains.kotlin.fir.references.builder.buildSimpleNamedReference
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 private object ConeConditionalEffectToFirVisitor : ConeContractDescriptionVisitor<FirExpression?, Map<Int, FirExpression>>() {
@@ -21,8 +22,8 @@ private object ConeConditionalEffectToFirVisitor : ConeContractDescriptionVisito
 
     override fun visitConstantDescriptor(constantReference: ConeConstantReference, data: Map<Int, FirExpression>): FirExpression? {
         return when (constantReference) {
-            ConeBooleanConstantReference.TRUE -> FirConstExpressionImpl(null, FirConstKind.Boolean, true)
-            ConeBooleanConstantReference.FALSE -> FirConstExpressionImpl(null, FirConstKind.Boolean, false)
+            ConeBooleanConstantReference.TRUE -> buildConstExpression(null, FirConstKind.Boolean, true)
+            ConeBooleanConstantReference.FALSE -> buildConstExpression(null, FirConstKind.Boolean, false)
             ConeConstantReference.NULL -> createConstNull()
             else -> null
         }
@@ -34,34 +35,40 @@ private object ConeConditionalEffectToFirVisitor : ConeContractDescriptionVisito
     ): FirExpression? {
         val leftExpression = binaryLogicExpression.left.accept(this, data) ?: return null
         val rightExpression = binaryLogicExpression.right.accept(this, data) ?: return null
-        return FirBinaryLogicExpressionImpl(null, leftExpression, rightExpression, binaryLogicExpression.kind)
+        return buildBinaryLogicExpression {
+            leftOperand = leftExpression
+            rightOperand = rightExpression
+            binaryLogicExpression.kind
+        }
     }
 
     override fun visitLogicalNot(logicalNot: ConeLogicalNot, data: Map<Int, FirExpression>): FirExpression? {
         val explicitReceiver = logicalNot.arg.accept(this, data) ?: return null
-        return FirFunctionCallImpl(null).apply {
-            calleeReference = FirSimpleNamedReference(null, OperatorNameConventions.NOT, null)
+        return buildFunctionCall {
+            calleeReference = buildSimpleNamedReference { name = OperatorNameConventions.NOT }
             this.explicitReceiver = explicitReceiver
         }
     }
 
     override fun visitIsInstancePredicate(isInstancePredicate: ConeIsInstancePredicate, data: Map<Int, FirExpression>): FirExpression? {
-        val operation = if (isInstancePredicate.isNegated) {
-            FirOperation.NOT_IS
-        } else {
-            FirOperation.IS
+        return buildTypeOperatorCall {
+            operation = if (isInstancePredicate.isNegated) {
+                FirOperation.NOT_IS
+            } else {
+                FirOperation.IS
+            }
+            conversionTypeRef = buildResolvedTypeRef { type = isInstancePredicate.type }
         }
-        return FirTypeOperatorCallImpl(null, operation, FirResolvedTypeRefImpl(null, isInstancePredicate.type))
     }
 
     override fun visitIsNullPredicate(isNullPredicate: ConeIsNullPredicate, data: Map<Int, FirExpression>): FirExpression? {
         val argument = isNullPredicate.arg.accept(this, data) ?: return null
-        val operation = if (isNullPredicate.isNegated) {
-            FirOperation.NOT_EQ
-        } else {
-            FirOperation.EQ
-        }
-        return FirOperatorCallImpl(null, operation).apply {
+        return buildOperatorCall {
+            operation = if (isNullPredicate.isNegated) {
+                FirOperation.NOT_EQ
+            } else {
+                FirOperation.EQ
+            }
             arguments += argument
             arguments += createConstNull()
         }
@@ -71,7 +78,7 @@ private object ConeConditionalEffectToFirVisitor : ConeContractDescriptionVisito
         return data[valueParameterReference.parameterIndex]
     }
 
-    private fun createConstNull(): FirConstExpression<*> = FirConstExpressionImpl(null, FirConstKind.Null, null)
+    private fun createConstNull(): FirConstExpression<*> = buildConstExpression(null, FirConstKind.Null, null)
 }
 
 fun ConeConditionalEffectDeclaration.buildContractFir(argumentMapping: Map<Int, FirExpression>): FirExpression? {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirBuiltinSymbolProvider.kt

@@ -13,6 +13,10 @@ import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.builder.buildClassImpl
+import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.builder.buildTypeParameter
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.*
 import org.jetbrains.kotlin.fir.deserialization.FirBuiltinAnnotationDeserializer
 import org.jetbrains.kotlin.fir.deserialization.FirDeserializationContext
@@ -27,8 +31,8 @@ import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
 import org.jetbrains.kotlin.metadata.deserialization.NameResolverImpl
@@ -46,7 +50,7 @@ import java.io.InputStream
 class FirBuiltinSymbolProvider(val session: FirSession, val kotlinScopeProvider: KotlinScopeProvider) : FirSymbolProvider() {
     private class BuiltInsPackageFragment(
         stream: InputStream, val fqName: FqName, val session: FirSession,
-        val kotlinScopeProvider: KotlinScopeProvider
+        val kotlinScopeProvider: KotlinScopeProvider,
     ) {
         lateinit var version: BuiltInsBinaryVersion
 
@@ -59,7 +63,7 @@ class FirBuiltinSymbolProvider(val session: FirSession, val kotlinScopeProvider:
                 throw UnsupportedOperationException(
                     "Kotlin built-in definition format version is not supported: " +
                             "expected ${BuiltInsBinaryVersion.INSTANCE}, actual $version. " +
-                            "Please update Kotlin"
+                            "Please update Kotlin",
                 )
             }
 
@@ -73,7 +77,7 @@ class FirBuiltinSymbolProvider(val session: FirSession, val kotlinScopeProvider:
         private val memberDeserializer by lazy {
             FirDeserializationContext.createForPackage(
                 fqName, packageProto.`package`, nameResolver, session,
-                FirBuiltinAnnotationDeserializer(session)
+                FirBuiltinAnnotationDeserializer(session),
             ).memberDeserializer
         }
 
@@ -84,7 +88,7 @@ class FirBuiltinSymbolProvider(val session: FirSession, val kotlinScopeProvider:
 
         private fun findAndDeserializeClass(
             classId: ClassId,
-            parentContext: FirDeserializationContext? = null
+            parentContext: FirDeserializationContext? = null,
         ): FirRegularClassSymbol? {
             val classIdExists = classId in classDataFinder.allClassIds
             if (!classIdExists) return null
@@ -95,7 +99,7 @@ class FirBuiltinSymbolProvider(val session: FirSession, val kotlinScopeProvider:
                 deserializeClassToSymbol(
                     classId, classProto, symbol, nameResolver, session,
                     null, kotlinScopeProvider, parentContext,
-                    this::findAndDeserializeClass
+                    this::findAndDeserializeClass,
                 )
             }
         }
@@ -148,48 +152,43 @@ class FirBuiltinSymbolProvider(val session: FirSession, val kotlinScopeProvider:
             val prefix = kind.classNamePrefix
             val arity = className.substring(prefix.length).toIntOrNull() ?: return null
             syntheticFunctionalInterfaceSymbols.getOrPut(SyntheticFunctionalInterfaceSymbolKey(kind, arity)) {
-                val status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.ABSTRACT).apply {
-                    isExpect = false
-                    isActual = false
-                    isInner = false
-                    isCompanion = false
-                    isData = false
-                    isInline = false
-                }
-                FirRegularClassSymbol(this).apply {
-                    FirClassImpl(
-                        null,
-                        session,
-                        status,
-                        ClassKind.INTERFACE,
-                        kotlinScopeProvider,
-                        relativeClassName.shortName(),
-                        this
-                    ).apply klass@{
+                FirRegularClassSymbol(this).apply symbol@{
+                    buildClassImpl klass@{
+                        session = this@FirBuiltinSymbolProvider.session
+                        name = relativeClassName.shortName()
+                        status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.ABSTRACT).apply {
+                            isExpect = false
+                            isActual = false
+                            isInner = false
+                            isCompanion = false
+                            isData = false
+                            isInline = false
+                        }
+                        classKind = ClassKind.INTERFACE
+                        scopeProvider = kotlinScopeProvider
+                        symbol = this@symbol
                         resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
-                        typeParameters.addAll((1..arity).map {
-                            FirTypeParameterImpl(
-                                null,
-                                this@FirBuiltinSymbolProvider.session,
-                                Name.identifier("P$it"),
-                                FirTypeParameterSymbol(),
-                                Variance.IN_VARIANCE,
-                                false
-                            ).apply {
-                                bounds += session.builtinTypes.nullableAnyType
-                            }
-                        })
+                        typeParameters.addAll(
+                            (1..arity).map {
+                                buildTypeParameter {
+                                    session = this@FirBuiltinSymbolProvider.session
+                                    name = Name.identifier("P$it")
+                                    symbol = FirTypeParameterSymbol()
+                                    variance = Variance.IN_VARIANCE
+                                    isReified = false
+                                    bounds += session.builtinTypes.nullableAnyType
+                                }
+                            },
+                        )
                         typeParameters.add(
-                            FirTypeParameterImpl(
-                                null,
-                                this@FirBuiltinSymbolProvider.session,
-                                Name.identifier("R"),
-                                FirTypeParameterSymbol(),
-                                Variance.OUT_VARIANCE,
-                                false
-                            ).apply {
+                            buildTypeParameter {
+                                session = this@FirBuiltinSymbolProvider.session
+                                name = Name.identifier("R")
+                                symbol = FirTypeParameterSymbol()
+                                variance = Variance.OUT_VARIANCE
+                                isReified = false
                                 bounds += session.builtinTypes.nullableAnyType
-                            }
+                            },
                         )
                         val name = OperatorNameConventions.INVOKE
                         val functionStatus = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.ABSTRACT).apply {
@@ -206,70 +205,60 @@ class FirBuiltinSymbolProvider(val session: FirSession, val kotlinScopeProvider:
                                         kind == FunctionClassDescriptor.Kind.KSuspendFunction
                         }
                         val typeArguments = typeParameters.map {
-                            FirResolvedTypeRefImpl(
-                                null,
-                                ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false)
-                            )
+                            buildResolvedTypeRef {
+                                type = ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false)
+                            }
                         }
 
                         addDeclaration(
-                            FirSimpleFunctionImpl(
-                                null,
-                                this@FirBuiltinSymbolProvider.session,
-                                typeArguments.last(),
-                                null,
-                                functionStatus,
-                                name,
-                                FirNamedFunctionSymbol(CallableId(packageFqName, relativeClassName, name))
-                            ).apply {
+                            buildSimpleFunction {
+                                session = this@FirBuiltinSymbolProvider.session
+                                returnTypeRef = typeArguments.last()
+                                this.name = name
+                                status = functionStatus
+                                symbol = FirNamedFunctionSymbol(CallableId(packageFqName, relativeClassName, name))
                                 resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
                                 valueParameters += typeArguments.dropLast(1).mapIndexed { index, typeArgument ->
                                     val parameterName = Name.identifier("p${index + 1}")
-                                    FirValueParameterImpl(
-                                        null,
-                                        this@FirBuiltinSymbolProvider.session,
-                                        typeArgument,
-                                        parameterName,
-                                        FirVariableSymbol(parameterName),
-                                        defaultValue = null,
-                                        isCrossinline = false,
-                                        isNoinline = false,
+                                    buildValueParameter {
+                                        session = this@FirBuiltinSymbolProvider.session
+                                        returnTypeRef = typeArgument
+                                        this.name = parameterName
+                                        symbol = FirVariableSymbol(parameterName)
+                                        defaultValue = null
+                                        isCrossinline = false
+                                        isNoinline = false
                                         isVararg = false
-                                    )
+                                    }
                                 }
-                            }
+                            },
                         )
 
                         fun createSuperType(
-                            kind: FunctionClassDescriptor.Kind
+                            kind: FunctionClassDescriptor.Kind,
                         ): FirResolvedTypeRef {
-                            return FirResolvedTypeRefImpl(
-                                null,
-                                ConeClassLikeLookupTagImpl(kind.classId(arity))
+                            return buildResolvedTypeRef {
+                                type = ConeClassLikeLookupTagImpl(kind.classId(arity))
                                     .constructClassType(typeArguments.map { it.type }.toTypedArray(), isNullable = false)
-                            )
+                            }
                         }
 
-                        val superTypes = when (kind) {
+                        superTypeRefs += when (kind) {
                             FunctionClassDescriptor.Kind.Function ->
-                                listOf(
-                                    FirResolvedTypeRefImpl(
-                                        source = null,
-                                        ConeClassLikeLookupTagImpl(StandardClassIds.Function)
-                                            .constructClassType(arrayOf(typeArguments.last().type), isNullable = false)
-                                    )
-                                )
+                                buildResolvedTypeRef {
+                                    type = ConeClassLikeLookupTagImpl(StandardClassIds.Function)
+                                        .constructClassType(arrayOf(typeArguments.last().type), isNullable = false)
+                                }
 
                             FunctionClassDescriptor.Kind.SuspendFunction ->
-                                listOf(session.builtinTypes.anyType)
+                                session.builtinTypes.anyType
 
                             FunctionClassDescriptor.Kind.KFunction ->
-                                listOf(createSuperType(FunctionClassDescriptor.Kind.Function))
+                                createSuperType(FunctionClassDescriptor.Kind.Function)
 
                             FunctionClassDescriptor.Kind.KSuspendFunction ->
-                                listOf(createSuperType(FunctionClassDescriptor.Kind.SuspendFunction))
+                                createSuperType(FunctionClassDescriptor.Kind.SuspendFunction)
                         }
-                        replaceSuperTypeRefs(superTypes)
                     }
                 }
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.inference
 
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
-import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirResolvable
@@ -15,8 +15,8 @@ import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.calls.*
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
-import org.jetbrains.kotlin.fir.resolve.transformers.FirCallCompletionResultsWriterTransformer
-import org.jetbrains.kotlin.fir.resolve.transformers.InvocationKindTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.*
+import org.jetbrains.kotlin.fir.resolve.transformers.MapArguments
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.visitors.transformSingle
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.components.InferenceSession
@@ -119,17 +119,16 @@ class FirCallCompleter(
                 needItParam -> {
                     val name = Name.identifier("it")
                     val itType = parameters.single()
-                    FirValueParameterImpl(
-                        null,
-                        session,
-                        FirResolvedTypeRefImpl(null, itType.approximateLambdaInputType()),
-                        name,
-                        FirVariableSymbol(name),
-                        defaultValue = null,
-                        isCrossinline = false,
-                        isNoinline = false,
+                    buildValueParameter {
+                        session = this@FirCallCompleter.session
+                        returnTypeRef = buildResolvedTypeRef { type = itType.approximateLambdaInputType() }
+                        this.name = name
+                        symbol = FirVariableSymbol(name)
+                        defaultValue = null
+                        isCrossinline = false
+                        isNoinline = false
                         isVararg = false
-                    )
+                    }
                 }
                 else -> null
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt

@@ -9,10 +9,10 @@ import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.builder.buildVarargArgumentsExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirVarargArgumentsExpressionImpl
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedCallableReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
+import org.jetbrains.kotlin.fir.references.builder.buildResolvedCallableReference
+import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.calls.Candidate
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
 import org.jetbrains.kotlin.fir.resolve.calls.isBuiltinFunctionalType
@@ -25,10 +25,10 @@ import org.jetbrains.kotlin.fir.resolve.withNullability
 import org.jetbrains.kotlin.fir.scopes.impl.FirIntegerOperatorCall
 import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildTypeProjectionWithVariance
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
-import org.jetbrains.kotlin.fir.types.impl.FirTypeProjectionWithVarianceImpl
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.fir.visitors.transformSingle
@@ -43,12 +43,12 @@ class FirCallCompletionResultsWriterTransformer(
     private val typeCalculator: ReturnTypeCalculator,
     private val typeApproximator: AbstractTypeApproximator,
     private val integerOperatorsTypeUpdater: IntegerOperatorsTypeUpdater,
-    private val integerApproximator: IntegerLiteralTypeApproximationTransformer
+    private val integerApproximator: IntegerLiteralTypeApproximationTransformer,
 ) : FirAbstractTreeTransformer<ExpectedArgumentType?>(phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
 
     override fun transformQualifiedAccessExpression(
         qualifiedAccessExpression: FirQualifiedAccessExpression,
-        data: ExpectedArgumentType?
+        data: ExpectedArgumentType?,
     ): CompositeTransformResult<FirStatement> {
         val calleeReference =
             qualifiedAccessExpression.calleeReference as? FirNamedReferenceWithCandidate ?: return qualifiedAccessExpression.compose()
@@ -56,26 +56,26 @@ class FirCallCompletionResultsWriterTransformer(
         val candidateFir = calleeReference.candidateSymbol.phasedFir
         val typeRef = (candidateFir as? FirTypedDeclaration)?.let {
             typeCalculator.tryCalculateReturnType(it)
-        } ?: FirErrorTypeRefImpl(
-            calleeReference.source,
-            FirSimpleDiagnostic("Callee reference to candidate without return type: ${candidateFir.render()}")
-        )
+        } ?: buildErrorTypeRef {
+            source = calleeReference.source
+            diagnostic = FirSimpleDiagnostic("Callee reference to candidate without return type: ${candidateFir.render()}")
+        }
 
         qualifiedAccessExpression.replaceTypeRefWithSubstituted(calleeReference, typeRef)
 
         return qualifiedAccessExpression.transformCalleeReference(
             StoreCalleeReference,
-            FirResolvedNamedReferenceImpl(
-                calleeReference.source,
-                calleeReference.name,
-                calleeReference.candidateSymbol
-            )
+            buildResolvedNamedReference {
+                source = calleeReference.source
+                name = calleeReference.name
+                resolvedSymbol = calleeReference.candidateSymbol
+            },
         ).compose()
     }
 
     private fun <D : FirExpression> D.replaceTypeRefWithSubstituted(
         calleeReference: FirNamedReferenceWithCandidate,
-        typeRef: FirResolvedTypeRef
+        typeRef: FirResolvedTypeRef,
     ): D {
         val resultTypeRef = typeRef.substituteTypeRef(calleeReference.candidate)
         replaceTypeRef(resultTypeRef)
@@ -83,12 +83,12 @@ class FirCallCompletionResultsWriterTransformer(
     }
 
     private fun FirResolvedTypeRef.substituteTypeRef(
-        candidate: Candidate
+        candidate: Candidate,
     ): FirResolvedTypeRef {
         val initialType = candidate.substitutor.substituteOrNull(type)
         val finalType = finalSubstitutor.substituteOrNull(initialType)?.let { substitutedType ->
             typeApproximator.approximateToSuperType(
-                substitutedType, TypeApproximatorConfiguration.FinalApproximationAfterResolutionAndInference
+                substitutedType, TypeApproximatorConfiguration.FinalApproximationAfterResolutionAndInference,
             ) as ConeKotlinType? ?: substitutedType
         }
 
@@ -97,7 +97,7 @@ class FirCallCompletionResultsWriterTransformer(
 
     override fun transformCallableReferenceAccess(
         callableReferenceAccess: FirCallableReferenceAccess,
-        data: ExpectedArgumentType?
+        data: ExpectedArgumentType?,
     ): CompositeTransformResult<FirStatement> {
         val calleeReference =
             callableReferenceAccess.calleeReference as? FirNamedReferenceWithCandidate ?: return callableReferenceAccess.compose()
@@ -112,29 +112,28 @@ class FirCallCompletionResultsWriterTransformer(
 
         return callableReferenceAccess.transformCalleeReference(
             StoreCalleeReference,
-            FirResolvedCallableReferenceImpl(
-                calleeReference.source,
-                calleeReference.name,
-                calleeReference.candidateSymbol
-            ).apply {
+            buildResolvedCallableReference {
+                source = calleeReference.source
+                name = calleeReference.name
+                resolvedSymbol = calleeReference.candidateSymbol
                 inferredTypeArguments.addAll(computeTypeArguments(calleeReference.candidate))
-            }
+            },
         ).compose()
     }
 
     override fun transformVariableAssignment(
         variableAssignment: FirVariableAssignment,
-        data: ExpectedArgumentType?
+        data: ExpectedArgumentType?,
     ): CompositeTransformResult<FirStatement> {
         val calleeReference = variableAssignment.calleeReference as? FirNamedReferenceWithCandidate
             ?: return variableAssignment.compose()
         return variableAssignment.transformCalleeReference(
             StoreCalleeReference,
-            FirResolvedNamedReferenceImpl(
-                calleeReference.source,
-                calleeReference.name,
-                calleeReference.candidateSymbol
-            )
+            buildResolvedNamedReference {
+                source = calleeReference.source
+                name = calleeReference.name
+                resolvedSymbol = calleeReference.candidateSymbol
+            },
         ).compose()
     }
 
@@ -148,18 +147,20 @@ class FirCallCompletionResultsWriterTransformer(
                 when (val argument = functionCall.typeArguments.getOrNull(index)) {
                     is FirTypeProjectionWithVariance -> {
                         val typeRef = argument.typeRef as FirResolvedTypeRef
-                        FirTypeProjectionWithVarianceImpl(
-                            argument.source,
-                            typeRef.withReplacedConeType(type),
-                            argument.variance
-                        )
+                        buildTypeProjectionWithVariance {
+                            source = argument.source
+                            this.typeRef = typeRef.withReplacedConeType(type)
+                            variance = argument.variance
+                        }
                     }
                     else -> {
-                        FirTypeProjectionWithVarianceImpl(
-                            argument?.source,
-                            FirResolvedTypeRefImpl(null, type),
-                            Variance.INVARIANT
-                        )
+                        buildTypeProjectionWithVariance {
+                            source = argument?.source
+                            typeRef = buildResolvedTypeRef {
+                                this.type = type
+                            }
+                            variance = Variance.INVARIANT
+                        }
                     }
                 }
             }
@@ -176,11 +177,11 @@ class FirCallCompletionResultsWriterTransformer(
         var result = functionCall.transformSingle(integerOperatorsTypeUpdater, null)
             .transformCalleeReference(
                 StoreCalleeReference,
-                FirResolvedNamedReferenceImpl(
-                    calleeReference.source,
-                    calleeReference.name,
-                    calleeReference.candidateSymbol
-                )
+                buildResolvedNamedReference {
+                    source = calleeReference.source
+                    name = calleeReference.name
+                    resolvedSymbol = calleeReference.candidateSymbol
+                },
             )
             .transformDispatchReceiver(StoreReceiver, subCandidate.dispatchReceiverExpression())
             .transformExtensionReceiver(StoreReceiver, subCandidate.extensionReceiverExpression())
@@ -195,27 +196,24 @@ class FirCallCompletionResultsWriterTransformer(
             else -> {
                 resultType = typeRef.substituteTypeRef(subCandidate)
                 val vararg = subCandidate.argumentMapping?.values?.firstOrNull { it.isVararg }
-                result.transformArguments(this, subCandidate.createArgumentsMapping()).apply {
+                result.transformArguments(this, subCandidate.createArgumentsMapping()).apply call@{
                     if (vararg != null && this is FirFunctionCallImpl) {
                         // Create a FirVarargArgumentExpression for the vararg arguments
                         val resolvedArrayType = vararg.returnTypeRef.substitute(subCandidate)
                         val resolvedElementType = resolvedArrayType.arrayElementType(session)
-                        val varargArgument = FirVarargArgumentsExpressionImpl(
-                            null,
-                            vararg.returnTypeRef.withReplacedConeType(resolvedElementType)
-                        )
-                        varargArgument.replaceTypeRef(
-                            vararg.returnTypeRef.withReplacedConeType(
+                        var firstIndex = this@call.arguments.size
+                        val varargArgument = buildVarargArgumentsExpression {
+                            varargElementType = vararg.returnTypeRef.withReplacedConeType(resolvedElementType)
+                            this.typeRef = vararg.returnTypeRef.withReplacedConeType(
                                 vararg.returnTypeRef.substitute(
                                     subCandidate
                                 )
                             )
-                        )
-                        var firstIndex = arguments.size
-                        for ((i, arg) in arguments.withIndex()) {
-                            if (subCandidate.argumentMapping!![arg]?.isVararg ?: false) {
-                                firstIndex = min(firstIndex, i)
-                                varargArgument.arguments.add(arg)
+                            for ((i, arg) in this@call.arguments.withIndex()) {
+                                if (subCandidate.argumentMapping!![arg]?.isVararg ?: false) {
+                                    firstIndex = min(firstIndex, i)
+                                    arguments += arg
+                                }
                             }
                         }
                         for (arg in varargArgument.arguments) {
@@ -229,7 +227,7 @@ class FirCallCompletionResultsWriterTransformer(
 
         return result.copy(
             resultType = resultType,
-            typeArguments = typeArguments
+            typeArguments = typeArguments,
         ).compose()
     }
 
@@ -248,7 +246,7 @@ class FirCallCompletionResultsWriterTransformer(
 
     override fun transformDelegatedConstructorCall(
         delegatedConstructorCall: FirDelegatedConstructorCall,
-        data: ExpectedArgumentType?
+        data: ExpectedArgumentType?,
     ): CompositeTransformResult<FirStatement> {
         val calleeReference =
             delegatedConstructorCall.calleeReference as? FirNamedReferenceWithCandidate ?: return delegatedConstructorCall.compose()
@@ -256,16 +254,16 @@ class FirCallCompletionResultsWriterTransformer(
         val result = delegatedConstructorCall.transformArguments(this, calleeReference.candidate.createArgumentsMapping())
         return result.transformCalleeReference(
             StoreCalleeReference,
-            FirResolvedNamedReferenceImpl(
-                calleeReference.source,
-                calleeReference.name,
-                calleeReference.candidateSymbol
-            )
+            buildResolvedNamedReference {
+                source = calleeReference.source
+                name = calleeReference.name
+                resolvedSymbol = calleeReference.candidateSymbol
+            },
         ).compose()
     }
 
     private fun computeTypeArguments(
-        candidate: Candidate
+        candidate: Candidate,
     ): List<ConeKotlinType> {
         val declaration = candidate.symbol.phasedFir as? FirCallableMemberDeclaration<*> ?: return emptyList()
 
@@ -276,7 +274,7 @@ class FirCallCompletionResultsWriterTransformer(
 
     override fun transformAnonymousFunction(
         anonymousFunction: FirAnonymousFunction,
-        data: ExpectedArgumentType?
+        data: ExpectedArgumentType?,
     ): CompositeTransformResult<FirStatement> {
         val expectedReturnType = data?.getExpectedType(anonymousFunction)
             ?.takeIf { it.isBuiltinFunctionalType(session) }
@@ -321,7 +319,7 @@ class FirCallCompletionResultsWriterTransformer(
 
     private inline fun <reified D> transformSyntheticCall(
         syntheticCall: D,
-        data: ExpectedArgumentType?
+        data: ExpectedArgumentType?,
     ): CompositeTransformResult<FirStatement>
             where D : FirResolvable, D : FirExpression {
         val syntheticCall = syntheticCall.transformChildren(this, data?.getExpectedType(syntheticCall)?.toExpectedType()) as D
@@ -334,17 +332,17 @@ class FirCallCompletionResultsWriterTransformer(
 
         return (syntheticCall.transformCalleeReference(
             StoreCalleeReference,
-            FirResolvedNamedReferenceImpl(
-                calleeReference.source,
-                calleeReference.name,
-                calleeReference.candidateSymbol
-            )
+            buildResolvedNamedReference {
+                source = calleeReference.source
+                name = calleeReference.name
+                resolvedSymbol = calleeReference.candidateSymbol
+            },
         ) as D).compose()
     }
 
     override fun <T> transformConstExpression(
         constExpression: FirConstExpression<T>,
-        data: ExpectedArgumentType?
+        data: ExpectedArgumentType?,
     ): CompositeTransformResult<FirStatement> {
         if (data == ExpectedArgumentType.NoApproximation) return constExpression.compose()
         val expectedType = data?.getExpectedType(constExpression)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirImport
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
+import org.jetbrains.kotlin.fir.declarations.builder.buildResolvedImport
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
@@ -52,10 +52,12 @@ class FirImportResolveTransformer() : FirAbstractTreeTransformer<Nothing?>(phase
 
     private fun transformImportForFqName(fqName: FqName, delegate: FirImport): CompositeTransformResult<FirImport> {
         val (packageFqName, relativeClassFqName) = resolveToPackageOrClass(symbolProvider, fqName) ?: return delegate.compose()
-        return FirResolvedImportImpl(delegate, packageFqName, relativeClassFqName).compose()
+        return buildResolvedImport {
+            this.delegate = delegate
+            this.packageFqName = packageFqName
+            relativeClassName = relativeClassFqName
+        }.compose()
     }
-
-
 }
 
 fun resolveToPackageOrClass(symbolProvider: FirSymbolProvider, fqName: FqName): PackageOrClass? {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt

@@ -10,8 +10,8 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
 import org.jetbrains.kotlin.fir.scopes.FirIterableScope
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedFunctionTypeRefImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedFunctionTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
 
@@ -28,23 +28,21 @@ class FirSpecificTypeResolverTransformer(
 
     override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
         functionTypeRef.transformChildren(this, data)
-        return FirResolvedFunctionTypeRefImpl(
-            functionTypeRef.source,
-            typeResolver.resolveType(functionTypeRef, towerScope),
-            functionTypeRef.isMarkedNullable,
-            functionTypeRef.receiverTypeRef,
-            functionTypeRef.returnTypeRef
-        ).apply {
+        return buildResolvedFunctionTypeRef {
+            source = functionTypeRef.source
+            type = typeResolver.resolveType(functionTypeRef, towerScope)
+            isMarkedNullable = functionTypeRef.isMarkedNullable
+            receiverTypeRef = functionTypeRef.receiverTypeRef
+            returnTypeRef = functionTypeRef.returnTypeRef
             annotations += functionTypeRef.annotations
             valueParameters += functionTypeRef.valueParameters
         }.compose()
     }
 
     private fun transformType(typeRef: FirTypeRef, resolvedType: ConeKotlinType): CompositeTransformResult<FirTypeRef> {
-        return FirResolvedTypeRefImpl(
-            typeRef.source,
-            resolvedType
-        ).apply {
+        return buildResolvedTypeRef {
+            source = typeRef.source
+            type = resolvedType
             annotations += typeRef.annotations
             delegatedTypeRef = typeRef
         }.compose()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirMemberTypeParameterScope
 import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
@@ -264,7 +264,10 @@ private class FirSupertypeResolverVisitor(
     }
 }
 
-private fun createErrorTypeRef(fir: FirElement, message: String) = FirErrorTypeRefImpl(fir.source, FirSimpleDiagnostic(message))
+private fun createErrorTypeRef(fir: FirElement, message: String) = buildErrorTypeRef {
+    source = fir.source
+    diagnostic = FirSimpleDiagnostic(message)
+}
 
 private class SupertypeComputationSession {
     private val fileScopesMap = hashMapOf<FirFile, FirImmutableCompositeScope>()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt

@@ -8,19 +8,19 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.copy
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary
+import org.jetbrains.kotlin.fir.declarations.builder.FirSimpleFunctionBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.buildTypeParameter
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
+import org.jetbrains.kotlin.fir.expressions.builder.buildFunctionCall
 import org.jetbrains.kotlin.fir.inferenceContext
 import org.jetbrains.kotlin.fir.references.FirReference
-import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
+import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirStubReference
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.calls.*
@@ -34,9 +34,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildTypeProjectionWithVariance
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
-import org.jetbrains.kotlin.fir.types.impl.FirTypeProjectionWithVarianceImpl
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.compose
@@ -48,10 +48,10 @@ class FirSyntheticCallGenerator(
     private val components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents,
     private val callCompleter: FirCallCompleter
 ) : BodyResolveComponents by components {
-    private val whenSelectFunction: FirSimpleFunctionImpl = generateSyntheticSelectFunction(SyntheticCallableId.WHEN)
-    private val trySelectFunction: FirSimpleFunctionImpl = generateSyntheticSelectFunction(SyntheticCallableId.TRY)
-    private val idFunction: FirSimpleFunctionImpl = generateSyntheticSelectFunction(SyntheticCallableId.ID)
-    private val checkNotNullFunction: FirSimpleFunctionImpl = generateSyntheticCheckNotNullFunction()
+    private val whenSelectFunction: FirSimpleFunction = generateSyntheticSelectFunction(SyntheticCallableId.WHEN)
+    private val trySelectFunction: FirSimpleFunction = generateSyntheticSelectFunction(SyntheticCallableId.TRY)
+    private val idFunction: FirSimpleFunction = generateSyntheticSelectFunction(SyntheticCallableId.ID)
+    private val checkNotNullFunction: FirSimpleFunction = generateSyntheticCheckNotNullFunction()
 
     fun generateCalleeForWhenExpression(whenExpression: FirWhenExpression): FirWhenExpression? {
         val stubReference = whenExpression.calleeReference
@@ -115,19 +115,22 @@ class FirSyntheticCallGenerator(
                 idFunction, arguments, SyntheticCallableId.ID.callableName, CallKind.SyntheticIdForCallableReferencesResolution
             ) ?: return callableReferenceAccess.transformCalleeReference(
                 StoreCalleeReference,
-                FirErrorNamedReferenceImpl(
-                    callableReferenceAccess.source,
-                    FirUnresolvedNameError(callableReferenceAccess.calleeReference.name)
-                )
+                buildErrorNamedReference {
+                    source = callableReferenceAccess.source
+                    diagnostic = FirUnresolvedNameError(callableReferenceAccess.calleeReference.name)
+                }
             )
-        val fakeCallElement = FirFunctionCallImpl(null).copy(calleeReference = reference, arguments = arguments)
+        val fakeCallElement = buildFunctionCall {
+            calleeReference = reference
+            this.arguments += callableReferenceAccess
+        }
 
         val argument = callCompleter.completeCall(fakeCallElement, expectedTypeRef).arguments[0]
         return ((argument as? FirVarargArgumentsExpression)?.arguments?.get(0) ?: argument) as FirCallableReferenceAccess?
     }
 
     private fun generateCalleeReferenceWithCandidate(
-        function: FirSimpleFunctionImpl,
+        function: FirSimpleFunction,
         arguments: List<FirExpression>,
         name: Name,
         callKind: CallKind = CallKind.SyntheticSelect
@@ -142,7 +145,7 @@ class FirSyntheticCallGenerator(
         return FirNamedReferenceWithCandidate(null, name, candidate)
     }
 
-    private fun generateCandidate(callInfo: CallInfo, function: FirSimpleFunctionImpl): Candidate =
+    private fun generateCandidate(callInfo: CallInfo, function: FirSimpleFunction): Candidate =
         CandidateFactory(components, callInfo).createCandidate(
             symbol = function.symbol,
             explicitReceiverKind = ExplicitReceiverKind.NO_EXPLICIT_RECEIVER
@@ -160,28 +163,36 @@ class FirSyntheticCallGenerator(
         implicitReceiverStack = implicitReceiverStack
     )
 
-    private fun generateSyntheticSelectFunction(callableId: CallableId): FirSimpleFunctionImpl {
+    private fun generateSyntheticSelectFunction(callableId: CallableId): FirSimpleFunction {
         // Synthetic function signature:
         //   fun <K> select(vararg values: K): K
         val functionSymbol = FirSyntheticFunctionSymbol(callableId)
         val typeParameterSymbol = FirTypeParameterSymbol()
         val typeParameter =
-            FirTypeParameterImpl(null, session, Name.identifier("K"), typeParameterSymbol, Variance.INVARIANT, false).apply {
+            buildTypeParameter {
+                session = this@FirSyntheticCallGenerator.session
+                name = Name.identifier("K")
+                symbol = typeParameterSymbol
+                variance = Variance.INVARIANT
+                isReified = false
                 addDefaultBoundIfNecessary()
             }
 
-        val returnType = FirResolvedTypeRefImpl(null, ConeTypeParameterTypeImpl(typeParameterSymbol.toLookupTag(), false))
+        val returnType = buildResolvedTypeRef { type = ConeTypeParameterTypeImpl(typeParameterSymbol.toLookupTag(), false) }
 
-        val argumentType = FirResolvedTypeRefImpl(null, returnType.coneTypeUnsafe<ConeKotlinType>().createArrayOf(session))
-        val typeArgument = FirTypeProjectionWithVarianceImpl(null, returnType, Variance.INVARIANT)
-
-        return generateMemberFunction(session, functionSymbol, callableId.callableName, typeArgument.typeRef).apply {
-            typeParameters += typeParameter
-            valueParameters += argumentType.toValueParameter(session, "branches", isVararg = true)
+        val argumentType = buildResolvedTypeRef { type = returnType.coneTypeUnsafe<ConeKotlinType>().createArrayOf(session) }
+        val typeArgument = buildTypeProjectionWithVariance {
+            typeRef = returnType
+            variance = Variance.INVARIANT
         }
+
+        return generateMemberFunction(functionSymbol, callableId.callableName, typeArgument.typeRef).apply {
+            typeParameters += typeParameter
+            valueParameters += argumentType.toValueParameter("branches", isVararg = true)
+        }.build()
     }
 
-    private fun generateSyntheticCheckNotNullFunction(): FirSimpleFunctionImpl {
+    private fun generateSyntheticCheckNotNullFunction(): FirSimpleFunction {
         // Synthetic function signature:
         //   fun <K> checkNotNull(arg: K?): K
         //
@@ -191,74 +202,71 @@ class FirSyntheticCallGenerator(
         val functionSymbol = FirSyntheticFunctionSymbol(SyntheticCallableId.CHECK_NOT_NULL)
         val typeParameterSymbol = FirTypeParameterSymbol()
         val typeParameter =
-            FirTypeParameterImpl(null, session, Name.identifier("K"), typeParameterSymbol, Variance.INVARIANT, false).apply {
+            buildTypeParameter {
+                session = this@FirSyntheticCallGenerator.session
+                name = Name.identifier("K")
+                symbol = typeParameterSymbol
+                variance = Variance.INVARIANT
+                isReified = false
                 addDefaultBoundIfNecessary()
             }
 
-        val returnType = FirResolvedTypeRefImpl(null, ConeTypeParameterTypeImpl(typeParameterSymbol.toLookupTag(), false))
+        val returnType = buildResolvedTypeRef { type = ConeTypeParameterTypeImpl(typeParameterSymbol.toLookupTag(), false) }
 
-        val argumentType =
-            FirResolvedTypeRefImpl(
-                null, returnType.coneTypeUnsafe<ConeKotlinType>().withNullability(
-                    ConeNullability.NULLABLE, session.inferenceContext
-                )
-            )
-        val typeArgument = FirTypeProjectionWithVarianceImpl(null, returnType, Variance.INVARIANT)
+        val argumentType = buildResolvedTypeRef {
+            type = returnType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NULLABLE, session.inferenceContext)
+        }
+        val typeArgument = buildTypeProjectionWithVariance {
+            typeRef = returnType
+            variance = Variance.INVARIANT
+        }
 
         return generateMemberFunction(
-            session,
             functionSymbol,
             SyntheticCallableId.CHECK_NOT_NULL.callableName,
             typeArgument.typeRef
         ).apply {
             typeParameters += typeParameter
-            valueParameters += argumentType.toValueParameter(session, "arg")
-        }
+            valueParameters += argumentType.toValueParameter("arg")
+        }.build()
     }
 
     private fun generateMemberFunction(
-        session: FirSession, symbol: FirNamedFunctionSymbol, name: Name, returnType: FirTypeRef
-    ): FirSimpleFunctionImpl {
-        val status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.FINAL).apply {
-            isExpect = false
-            isActual = false
-            isOverride = false
-            isOperator = false
-            isInfix = false
-            isInline = false
-            isTailRec = false
-            isExternal = false
-            isSuspend = false
-        }
-        return FirSimpleFunctionImpl(
-            session = session,
-            source = null,
-            symbol = symbol,
-            name = name,
-            status = status,
-            receiverTypeRef = null,
+        symbol: FirNamedFunctionSymbol, name: Name, returnType: FirTypeRef
+    ): FirSimpleFunctionBuilder {
+        return FirSimpleFunctionBuilder().apply {
+            session = this@FirSyntheticCallGenerator.session
+            this.symbol = symbol
+            this.name = name
+            status = FirDeclarationStatusImpl(Visibilities.PUBLIC, Modality.FINAL).apply {
+                isExpect = false
+                isActual = false
+                isOverride = false
+                isOperator = false
+                isInfix = false
+                isInline = false
+                isTailRec = false
+                isExternal = false
+                isSuspend = false
+            }
             returnTypeRef = returnType
-        ).apply {
-            this.resolvePhase = FirResolvePhase.BODY_RESOLVE
+            resolvePhase = FirResolvePhase.BODY_RESOLVE
         }
     }
 
     private fun FirResolvedTypeRef.toValueParameter(
-        session: FirSession, nameAsString: String, isVararg: Boolean = false
-    ): FirValueParameterImpl {
+        nameAsString: String, isVararg: Boolean = false
+    ): FirValueParameter {
         val name = Name.identifier(nameAsString)
-        return FirValueParameterImpl(
-            session = session,
-            source = null,
-            name = name,
-            returnTypeRef = this,
-            defaultValue = null,
-            isCrossinline = false,
-            isNoinline = false,
-            isVararg = isVararg,
+        return buildValueParameter {
+            session = this@FirSyntheticCallGenerator.session
+            this.name = name
+            returnTypeRef = this@toValueParameter
+            isCrossinline = false
+            isNoinline = false
+            this.isVararg = isVararg
             symbol = FirVariableSymbol(name)
-        ).apply {
-            this.resolvePhase = FirResolvePhase.BODY_RESOLVE
+            resolvePhase = FirResolvePhase.BODY_RESOLVE
         }
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
 import org.jetbrains.kotlin.fir.types.ConeNullability

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt

@@ -6,10 +6,11 @@
 package org.jetbrains.kotlin.fir.resolve.transformers
 
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
-import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
+import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.calls.ConeInferenceContext
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
@@ -77,7 +78,13 @@ class IntegerLiteralTypeApproximationTransformer(
         // e.g. Byte doesn't have `and` in member scope. It's an extension
         if (resultSymbol == null) return functionCall.compose()
         functionCall.resultType = data?.let { functionCall.resultType.resolvedTypeFromPrototype(it) } ?: resultSymbol.fir.returnTypeRef
-        return functionCall.transformCalleeReference(StoreCalleeReference, FirResolvedNamedReferenceImpl(null, operator.name, resultSymbol!!)).compose()
+        return functionCall.transformCalleeReference(
+            StoreCalleeReference,
+            buildResolvedNamedReference {
+                name = operator.name
+                resolvedSymbol = resultSymbol!!
+            }
+        ).compose()
     }
 
     override fun transformOperatorCall(operatorCall: FirOperatorCall, data: ConeKotlinType?): CompositeTransformResult<FirStatement> {
@@ -190,17 +197,19 @@ class IntegerOperatorsTypeUpdater(val approximator: IntegerLiteralTypeApproximat
     }
 }
 
+@UseExperimental(FirImplementationDetail::class)
 private fun FirFunctionCall.toOperatorCall(): FirIntegerOperatorCall {
     if (this is FirIntegerOperatorCall) return this
-    return FirIntegerOperatorCall(source).also {
-        it.typeRef = typeRef
-        it.annotations += annotations
-        it.safe = safe
-        it.typeArguments += typeArguments
-        it.explicitReceiver = explicitReceiver
-        it.dispatchReceiver = dispatchReceiver
-        it.extensionReceiver = extensionReceiver
-        it.arguments += arguments
-        it.calleeReference = calleeReference
-    }
+    return FirIntegerOperatorCall(
+        source,
+        typeRef,
+        annotations.toMutableList(),
+        safe,
+        typeArguments.toMutableList(),
+        explicitReceiver,
+        dispatchReceiver,
+        extensionReceiver,
+        arguments.toMutableList(),
+        calleeReference,
+    )
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
 
 interface ReturnTypeCalculator {
     fun tryCalculateReturnType(declaration: FirTypedDeclaration): FirResolvedTypeRef
@@ -22,12 +22,11 @@ class ReturnTypeCalculatorForFullBodyResolve : ReturnTypeCalculator {
         val returnTypeRef = declaration.returnTypeRef
         if (returnTypeRef is FirResolvedTypeRef) return returnTypeRef
 
-        return FirErrorTypeRefImpl(
-            null,
-            FirSimpleDiagnostic(
+        return buildErrorTypeRef {
+            diagnostic = FirSimpleDiagnostic(
                 "Cannot calculate return type during full-body resolution (local class/object?): ${declaration.render()}",
                 DiagnosticKind.InferenceError
             )
-        )
+        }
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirBlockImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
 import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
@@ -38,8 +37,9 @@ internal object MapArguments : FirDefaultTransformer<Map<FirElement, FirElement>
         if (block.statements.isEmpty()) return block.compose()
         val transformedStatement = block.statements.last().transformSingle(this@MapArguments, data)
         when (block) {
-            is FirBlockImpl -> block.statements[block.statements.size - 1] = transformedStatement
             is FirSingleExpressionBlock -> block.statement = transformedStatement
+            // TODO: dirty cast
+            else -> (block.statements as MutableList<FirStatement>)[block.statements.size - 1] = transformedStatement
         }
         return block.compose()
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirTypeResolveScopeForBodyResolve
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
 
 abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAbstractPhaseTransformer<ResolutionMode>(phase) {
     abstract val components: BodyResolveTransformerComponents
@@ -97,7 +97,7 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb
         val topLevelScopes: MutableList<FirScope> = mutableListOf()
         val localScopes: MutableList<FirLocalScope> = mutableListOf()
 
-        override val noExpectedType: FirTypeRef = FirImplicitTypeRefImpl(null)
+        override val noExpectedType: FirTypeRef = buildImplicitTypeRef()
 
         override lateinit var file: FirFile
             internal set

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt

@@ -15,13 +15,12 @@ import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.transformers.FirSyntheticCallGenerator
 import org.jetbrains.kotlin.fir.resolve.transformers.FirWhenExhaustivenessTransformer
-import org.jetbrains.kotlin.fir.resolve.transformers.IntegerLiteralTypeApproximationTransformer
 import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
 import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.fir.visitors.transformSingle
@@ -77,7 +76,9 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
                     whenExpression = syntheticCallGenerator.generateCalleeForWhenExpression(whenExpression) ?: run {
                         whenExpression = whenExpression.transformSingle(whenExhaustivenessTransformer, null)
                         dataFlowAnalyzer.exitWhenExpression(whenExpression)
-                        whenExpression.resultType = FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Can't resolve when expression", DiagnosticKind.InferenceError))
+                        whenExpression.resultType = buildErrorTypeRef {
+                            diagnostic = FirSimpleDiagnostic("Can't resolve when expression", DiagnosticKind.InferenceError)
+                        }
                         return@with whenExpression.compose()
                     }
 
@@ -103,7 +104,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
         if (branches.size == 1) return true
         if (branches.size > 2) return false
         val lastBranch = branches.last()
-        return lastBranch.condition is FirElseIfTrueCondition && lastBranch.result is FirEmptyExpressionBlock
+        return lastBranch.source != null && lastBranch.condition is FirElseIfTrueCondition && lastBranch.result is FirEmptyExpressionBlock
     }
 
     override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): CompositeTransformResult<FirWhenBranch> {
@@ -143,7 +144,9 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
             val expectedTypeRef = data.expectedType
             callCompleter.completeCall(it, expectedTypeRef)
         } ?: run {
-            tryExpression.resultType = FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Can't resolve try expression", DiagnosticKind.InferenceError))
+            tryExpression.resultType = buildErrorTypeRef {
+                diagnostic = FirSimpleDiagnostic("Can't resolve try expression", DiagnosticKind.InferenceError)
+            }
             tryExpression
         }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -9,15 +9,15 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirFunctionTarget
 import org.jetbrains.kotlin.fir.copy
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
-import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
 import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.expressions.impl.FirReturnExpressionImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirUnitExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildReturnExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildUnitExpression
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.*
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -28,9 +28,9 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirMemberTypeParameterScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -256,7 +256,10 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
         prepareLocalClassForBodyResolve(anonymousObject)
         return withScopeCleanup(topLevelScopes) {
             val type = anonymousObject.defaultType()
-            anonymousObject.resultType = FirResolvedTypeRefImpl(anonymousObject.source, type)
+            anonymousObject.resultType = buildResolvedTypeRef {
+                source = anonymousObject.source
+                this.type = type
+            }
             val result = withLabelAndReceiverType(null, anonymousObject, type) {
                 transformDeclaration(anonymousObject, data)
             }
@@ -342,9 +345,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
             } else {
                 result.transformReturnTypeRef(
                     transformer,
-                    withExpectedType(
-                        FirErrorTypeRefImpl(null, FirSimpleDiagnostic("empty body", DiagnosticKind.Other))
-                    )
+                    withExpectedType(buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("empty body", DiagnosticKind.Other) })
                 )
             }
         }
@@ -413,7 +414,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                 transformAnonymousFunctionWithLambdaResolution(anonymousFunction, data).addReturn().compose()
             }
             is ResolutionMode.WithExpectedType, is ResolutionMode.ContextIndependent -> {
-                val expectedTypeRef = (data as? ResolutionMode.WithExpectedType)?.expectedTypeRef ?: FirImplicitTypeRefImpl(null)
+                val expectedTypeRef = (data as? ResolutionMode.WithExpectedType)?.expectedTypeRef ?: buildImplicitTypeRef()
                 val resolvedLambdaAtom = (expectedTypeRef as? FirResolvedTypeRef)?.let {
                     extractLambdaInfoFromFunctionalType(
                         it.type, it, anonymousFunction, session
@@ -427,17 +428,15 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                         val itParam = when {
                             af.valueParameters.isEmpty() && singleParameterType != null -> {
                                 val name = Name.identifier("it")
-                                FirValueParameterImpl(
-                                    null,
-                                    session,
-                                    FirResolvedTypeRefImpl(null, singleParameterType),
-                                    name,
-                                    FirVariableSymbol(name),
-                                    defaultValue = null,
-                                    isCrossinline = false,
-                                    isNoinline = false,
+                                buildValueParameter {
+                                    session = this@FirDeclarationsResolveTransformer.session
+                                    returnTypeRef = buildResolvedTypeRef { type = singleParameterType }
+                                    this.name = name
+                                    symbol = FirVariableSymbol(name)
+                                    isCrossinline = false
+                                    isNoinline = false
                                     isVararg = false
-                                )
+                                }
                             }
                             else -> null
                         }
@@ -502,9 +501,13 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                 object : FirDefaultTransformer<FirExpression>() {
                     override fun <E : FirElement> transformElement(element: E, data: FirExpression): CompositeTransformResult<E> {
                         if (element == lastStatement) {
-                            val returnExpression = FirReturnExpressionImpl(element.source, lastStatement)
-                            returnExpression.target = FirFunctionTarget(null)
-                            (returnExpression.target as FirFunctionTarget).bind(this@addReturn)
+                            val returnExpression = buildReturnExpression {
+                                source = element.source
+                                result = lastStatement
+                                target = FirFunctionTarget(null, isLambda = this@addReturn.isLambda).also {
+                                    it.bind(this@addReturn)
+                                }
+                            }
                             return (returnExpression as E).compose()
                         }
                         return element.compose()
@@ -517,7 +520,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                         return returnExpression.compose()
                     }
                 },
-                FirUnitExpression(null)
+                buildUnitExpression()
             )
         }
         return this
@@ -577,10 +580,9 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
             when {
                 initializer != null -> {
                     val expectedType = when (val resultType = initializer.resultType) {
-                        is FirImplicitTypeRef -> FirErrorTypeRefImpl(
-                            null,
-                            FirSimpleDiagnostic("No result type for initializer", DiagnosticKind.InferenceError)
-                        )
+                        is FirImplicitTypeRef -> buildErrorTypeRef {
+                            diagnostic = FirSimpleDiagnostic("No result type for initializer", DiagnosticKind.InferenceError)
+                        }
                         else -> resultType
                     }
                     variable.transformReturnTypeRef(
@@ -590,10 +592,9 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                 }
                 variable.getter != null && variable.getter !is FirDefaultPropertyAccessor -> {
                     val expectedType = when (val resultType = variable.getter?.returnTypeRef) {
-                        is FirImplicitTypeRef -> FirErrorTypeRefImpl(
-                            null,
-                            FirSimpleDiagnostic("No result type for getter", DiagnosticKind.InferenceError)
-                        )
+                        is FirImplicitTypeRef -> buildErrorTypeRef {
+                            diagnostic = FirSimpleDiagnostic("No result type for getter", DiagnosticKind.InferenceError)
+                        }
                         else -> resultType
                     }
                     variable.transformReturnTypeRef(
@@ -603,7 +604,15 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                 }
                 else -> {
                     variable.transformReturnTypeRef(
-                        transformer, withExpectedType(FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Cannot infer variable type without initializer / getter / delegate", DiagnosticKind.InferenceError)))
+                        transformer,
+                        withExpectedType(
+                            buildErrorTypeRef {
+                                diagnostic = FirSimpleDiagnostic(
+                                    "Cannot infer variable type without initializer / getter / delegate",
+                                    DiagnosticKind.InferenceError,
+                                )
+                            },
+                        )
                     )
                 }
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -11,13 +11,15 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedQualifierImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirVariableAssignmentImpl
-import org.jetbrains.kotlin.fir.references.*
-import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
-import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
+import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildFunctionCall
+import org.jetbrains.kotlin.fir.expressions.builder.buildVariableAssignment
+import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference
+import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.references.FirSuperReference
+import org.jetbrains.kotlin.fir.references.FirThisReference
+import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
+import org.jetbrains.kotlin.fir.references.builder.buildSimpleNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.candidate
@@ -33,7 +35,8 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.symbols.invoke
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.*
+import org.jetbrains.kotlin.fir.types.builder.*
+import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.fir.visitors.transformSingle
@@ -51,10 +54,11 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) {
-            val type = FirErrorTypeRefImpl(
-                expression.source,
-                FirSimpleDiagnostic("Type calculating for ${expression::class} is not supported", DiagnosticKind.InferenceError)
-            )
+            val type = buildErrorTypeRef {
+                source = expression.source
+                diagnostic =
+                    FirSimpleDiagnostic("Type calculating for ${expression::class} is not supported", DiagnosticKind.InferenceError)
+            }
             expression.resultType = type
         }
         return (expression.transformChildren(transformer, data) as FirStatement).compose()
@@ -62,21 +66,22 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformQualifiedAccessExpression(
         qualifiedAccessExpression: FirQualifiedAccessExpression,
-        data: ResolutionMode
+        data: ResolutionMode,
     ): CompositeTransformResult<FirStatement> {
         qualifiedAccessExpression.annotations.forEach { it.accept(this, data) }
         qualifiedAccessExpression.transformTypeArguments(transformer, ResolutionMode.ContextIndependent)
 
         var result = when (val callee = qualifiedAccessExpression.calleeReference) {
-            is FirExplicitThisReference -> {
+            // TODO: there was FirExplicitThisReference
+            is FirThisReference -> {
                 val labelName = callee.labelName
                 val implicitReceiver = implicitReceiverStack[labelName]
                 implicitReceiver?.boundSymbol?.let {
                     callee.replaceBoundSymbol(it)
                 }
-                qualifiedAccessExpression.resultType = FirResolvedTypeRefImpl(
-                    null, implicitReceiver?.type ?: ConeKotlinErrorType("Unresolved this@$labelName")
-                )
+                qualifiedAccessExpression.resultType = buildResolvedTypeRef {
+                    type = implicitReceiver?.type ?: ConeKotlinErrorType("Unresolved this@$labelName")
+                }
                 qualifiedAccessExpression
             }
             is FirSuperReference -> {
@@ -92,16 +97,18 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                         val superTypeRefs = implicitReceiverStack.lastDispatchReceiver()?.boundSymbol?.phasedFir?.superTypeRefs
                         val resultType = when {
                             superTypeRefs?.isNotEmpty() != true -> {
-                                FirErrorTypeRefImpl(
-                                    qualifiedAccessExpression.source, FirSimpleDiagnostic("No super type", DiagnosticKind.NoSupertype)
-                                )
+                                buildErrorTypeRef {
+                                    source = qualifiedAccessExpression.source
+                                    diagnostic = FirSimpleDiagnostic("No super type", DiagnosticKind.NoSupertype)
+                                }
                             }
                             superTypeRefs.size == 1 -> {
                                 superTypeRefs.single()
                             }
                             else -> {
-                                FirComposedSuperTypeRefImpl(qualifiedAccessExpression.source).apply {
-                                    this.superTypeRefs += superTypeRefs.map { it as FirResolvedTypeRef }
+                                buildComposedSuperTypeRef {
+                                    source = qualifiedAccessExpression.source
+                                    superTypeRefs.mapTo(this.superTypeRefs) { it as FirResolvedTypeRef }
                                 }
                             }
                         }
@@ -188,7 +195,9 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         block.resultType = if (resultExpression == null) {
             block.resultType.resolvedTypeFromPrototype(session.builtinTypes.unitType.type)
         } else {
-            (resultExpression.resultType as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(null, FirSimpleDiagnostic("No type for block", DiagnosticKind.InferenceError))
+            (resultExpression.resultType as? FirResolvedTypeRef) ?: buildErrorTypeRef {
+                diagnostic = FirSimpleDiagnostic("No type for block", DiagnosticKind.InferenceError)
+            }
         }
         dataFlowAnalyzer.exitBlock(block)
         return block.compose()
@@ -196,7 +205,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformThisReceiverExpression(
         thisReceiverExpression: FirThisReceiverExpression,
-        data: ResolutionMode
+        data: ResolutionMode,
     ): CompositeTransformResult<FirStatement> {
         return transformQualifiedAccessExpression(thisReceiverExpression, data)
     }
@@ -219,14 +228,15 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             val operatorCall = operatorCall.transformArguments(this, ResolutionMode.ContextIndependent)
             val (leftArgument, rightArgument) = operatorCall.arguments
 
-            fun createFunctionCall(name: Name) = FirFunctionCallImpl(operatorCall.source).apply {
+            fun createFunctionCall(name: Name) = buildFunctionCall {
+                source = operatorCall.source
                 explicitReceiver = leftArgument
                 arguments += rightArgument
-                calleeReference = FirSimpleNamedReference(
-                    operatorCall.source,
-                    name,
+                calleeReference = buildSimpleNamedReference {
+                    source = operatorCall.source
+                    this.name = name
                     candidateSymbol = null
-                )
+                }
             }
 
             // TODO: disable DataFlowAnalyzer for resolving that two calls
@@ -248,18 +258,24 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                 operatorCallReference == null || (!lhsIsVar && !assignIsError) -> resolvedAssignCall.compose()
                 assignCallReference == null -> {
                     val assignment =
-                        FirVariableAssignmentImpl(operatorCall.source, false, resolvedOperatorCall).apply {
-                            lValue = if (lhsIsVar)
+                        buildVariableAssignment {
+                            source = operatorCall.source
+                            safe = false
+                            rValue = resolvedOperatorCall
+                            calleeReference = if (lhsIsVar)
                                 lhsReference!!
                             else
-                                FirErrorNamedReferenceImpl(operatorCall.arguments.first().source, FirVariableExpectedError())
+                                buildErrorNamedReference {
+                                    source = operatorCall.arguments.first().source
+                                    diagnostic = FirVariableExpectedError()
+                                }
                         }
                     assignment.transform(transformer, ResolutionMode.ContextIndependent)
                 }
-                else -> FirErrorExpressionImpl(
-                    operatorCall.source,
-                    FirOperatorAmbiguityError(listOf(operatorCallReference.resolvedSymbol, assignCallReference.resolvedSymbol))
-                ).compose()
+                else -> buildErrorExpression {
+                    source = operatorCall.source
+                    diagnostic = FirOperatorAmbiguityError(listOf(operatorCallReference.resolvedSymbol, assignCallReference.resolvedSymbol))
+                }.compose()
             }
         }
 
@@ -268,7 +284,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformTypeOperatorCall(
         typeOperatorCall: FirTypeOperatorCall,
-        data: ResolutionMode
+        data: ResolutionMode,
     ): CompositeTransformResult<FirStatement> {
         val symbolProvider = session.firSymbolProvider
         val resolved = (transformExpression(typeOperatorCall, data).single as FirTypeOperatorCall)
@@ -284,8 +300,8 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                 resolved.resultType =
                     resolved.conversionTypeRef.withReplacedConeType(
                         resolved.conversionTypeRef.coneTypeUnsafe<ConeKotlinType>().withNullability(
-                            ConeNullability.NULLABLE, session.inferenceContext
-                        )
+                            ConeNullability.NULLABLE, session.inferenceContext,
+                        ),
                     )
             }
             else -> error("Unknown type operator")
@@ -296,7 +312,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformCheckNotNullCall(
         checkNotNullCall: FirCheckNotNullCall,
-        data: ResolutionMode
+        data: ResolutionMode,
     ): CompositeTransformResult<FirStatement> {
         // Resolve the return type of a call to the synthetic function with signature:
         //   fun <K> checkNotNull(arg: K?): K
@@ -312,7 +328,9 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             callCompleter.completeCall(it, data.expectedType)
         } ?: run {
             checkNotNullCall.resultType =
-                FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Can't resolve !! operator call", DiagnosticKind.InferenceError))
+                buildErrorTypeRef {
+                    diagnostic = FirSimpleDiagnostic("Can't resolve !! operator call", DiagnosticKind.InferenceError)
+                }
             checkNotNullCall
         }
         dataFlowAnalyzer.exitCheckNotNullCall(result)
@@ -321,18 +339,20 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformBinaryLogicExpression(
         binaryLogicExpression: FirBinaryLogicExpression,
-        data: ResolutionMode
+        data: ResolutionMode,
     ): CompositeTransformResult<FirStatement> {
         val booleanType = binaryLogicExpression.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type)
         return when (binaryLogicExpression.kind) {
             LogicOperationKind.AND ->
                 binaryLogicExpression.also(dataFlowAnalyzer::enterBinaryAnd)
-                    .transformLeftOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitLeftBinaryAndArgument)
+                    .transformLeftOperand(this, ResolutionMode.WithExpectedType(booleanType))
+                    .also(dataFlowAnalyzer::exitLeftBinaryAndArgument)
                     .transformRightOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitBinaryAnd)
 
             LogicOperationKind.OR ->
                 binaryLogicExpression.also(dataFlowAnalyzer::enterBinaryOr)
-                    .transformLeftOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitLeftBinaryOrArgument)
+                    .transformLeftOperand(this, ResolutionMode.WithExpectedType(booleanType))
+                    .also(dataFlowAnalyzer::exitLeftBinaryOrArgument)
                     .transformRightOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitBinaryOr)
         }.transformOtherChildren(transformer, ResolutionMode.WithExpectedType(booleanType)).also {
             it.resultType = booleanType
@@ -341,7 +361,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformVariableAssignment(
         variableAssignment: FirVariableAssignment,
-        data: ResolutionMode
+        data: ResolutionMode,
     ): CompositeTransformResult<FirStatement> {
         // val resolvedAssignment = transformCallee(variableAssignment)
         variableAssignment.annotations.forEach { it.accept(this, data) }
@@ -362,7 +382,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformCallableReferenceAccess(
         callableReferenceAccess: FirCallableReferenceAccess,
-        data: ResolutionMode
+        data: ResolutionMode,
     ): CompositeTransformResult<FirStatement> {
         if (callableReferenceAccess.calleeReference is FirResolvedNamedReference) {
             return callableReferenceAccess.compose()
@@ -371,8 +391,8 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         callableReferenceAccess.annotations.forEach { it.accept(this, data) }
         val explicitReceiver = callableReferenceAccess.explicitReceiver
         val transformedLHS = explicitReceiver?.transformSingle(this, ResolutionMode.ContextIndependent)?.apply {
-            if (this is FirResolvedQualifierImpl && callableReferenceAccess.safe) {
-                this.safe = true
+            if (this is FirResolvedQualifier && callableReferenceAccess.safe) {
+                replaceSafe(true)
             }
         }
 
@@ -385,7 +405,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         if (data !is ResolutionMode.ContextDependent) {
             val resolvedReference =
                 components.syntheticCallGenerator.resolveCallableReferenceWithSyntheticOuterCall(
-                    callableReferenceAccess, data.expectedType
+                    callableReferenceAccess, data.expectedType,
                 ) ?: callableReferenceAccess
 
             return resolvedReference.compose()
@@ -408,7 +428,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                         Array((symbol.phasedFir as? FirTypeParametersOwner)?.typeParameters?.size ?: 0) {
                             ConeStarProjection
                         },
-                        isNullable = false
+                        isNullable = false,
                     )
                 } else {
                     null
@@ -424,16 +444,15 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         }
 
         transformedGetClassCall.resultType =
-            FirResolvedTypeRefImpl(
-                null,
-                kClassSymbol.constructType(arrayOf(typeOfExpression), false)
-            )
+            buildResolvedTypeRef {
+                type = kClassSymbol.constructType(arrayOf(typeOfExpression), false)
+            }
         return transformedGetClassCall.compose()
     }
 
     override fun transformWrappedDelegateExpression(
         wrappedDelegateExpression: FirWrappedDelegateExpression,
-        data: ResolutionMode
+        data: ResolutionMode,
     ): CompositeTransformResult<FirStatement> {
         transformExpression(wrappedDelegateExpression, data)
         with(wrappedDelegateExpression) {
@@ -445,7 +464,10 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         }
     }
 
-    override fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun <T> transformConstExpression(
+        constExpression: FirConstExpression<T>,
+        data: ResolutionMode,
+    ): CompositeTransformResult<FirStatement> {
         constExpression.annotations.forEach { it.accept(this, data) }
         val kind = constExpression.kind
         val symbol = when (kind) {
@@ -473,10 +495,10 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                 if (newConstKind == null) {
                     constExpression.replaceKind(FirConstKind.Int as FirConstKind<T>)
                     dataFlowAnalyzer.exitConstExpresion(constExpression as FirConstExpression<*>)
-                    constExpression.resultType = FirErrorTypeRefImpl(
-                        constExpression.source,
-                        FirTypeMismatchError(expectedType, integerLiteralType.getApproximatedType())
-                    )
+                    constExpression.resultType = buildErrorTypeRef {
+                        source = constExpression.source
+                        diagnostic = FirTypeMismatchError(expectedType, integerLiteralType.getApproximatedType())
+                    }
                     return constExpression.compose()
                 }
                 constExpression.replaceKind(newConstKind as FirConstKind<T>)
@@ -500,29 +522,29 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
     }
 
     private fun ConeKotlinTypeProjection.toFirTypeProjection(): FirTypeProjection = when (this) {
-        is ConeStarProjection -> FirStarProjectionImpl(null)
+        is ConeStarProjection -> buildStarProjection()
         else -> {
-            val variance = when (kind) {
-                ProjectionKind.IN -> Variance.IN_VARIANCE
-                ProjectionKind.OUT -> Variance.OUT_VARIANCE
-                ProjectionKind.INVARIANT -> Variance.INVARIANT
-                ProjectionKind.STAR -> throw IllegalStateException()
-            }
             val type = when (this) {
                 is ConeKotlinTypeProjectionIn -> type
                 is ConeKotlinTypeProjectionOut -> type
                 is ConeStarProjection -> throw IllegalStateException()
                 else -> this as ConeKotlinType
             }
-            FirTypeProjectionWithVarianceImpl(
-                null, FirResolvedTypeRefImpl(null, type), variance
-            )
+            buildTypeProjectionWithVariance {
+                typeRef = buildResolvedTypeRef { this.type = type }
+                variance = when (kind) {
+                    ProjectionKind.IN -> Variance.IN_VARIANCE
+                    ProjectionKind.OUT -> Variance.OUT_VARIANCE
+                    ProjectionKind.INVARIANT -> Variance.INVARIANT
+                    ProjectionKind.STAR -> throw IllegalStateException()
+                }
+            }
         }
     }
 
     override fun transformDelegatedConstructorCall(
         delegatedConstructorCall: FirDelegatedConstructorCall,
-        data: ResolutionMode
+        data: ResolutionMode,
     ): CompositeTransformResult<FirStatement> {
         if (transformer.implicitTypeOnly) return delegatedConstructorCall.compose()
         delegatedConstructorCall.transformChildren(transformer, ResolutionMode.ContextDependent)
@@ -553,7 +575,8 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             }
             else -> return delegatedConstructorCall.compose()
         }
-        val result = callResolver.resolveDelegatingConstructorCall(delegatedConstructorCall, symbol, typeArguments) ?: return delegatedConstructorCall.compose()
+        val result = callResolver.resolveDelegatingConstructorCall(delegatedConstructorCall, symbol, typeArguments)
+            ?: return delegatedConstructorCall.compose()
         return callCompleter.completeCall(result, noExpectedType).compose()
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.TransformImplicitType
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
+import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -152,10 +152,9 @@ private class ReturnTypeCalculatorWithJump(
             // TODO?
             declaration.transformReturnTypeRef(
                 TransformImplicitType,
-                FirErrorTypeRefImpl(
-                    null,
-                    FirSimpleDiagnostic("Unsupported: implicit VP type")
-                )
+                buildErrorTypeRef {
+                    diagnostic = FirSimpleDiagnostic("Unsupported: implicit VP type")
+                }
             )
         }
 
@@ -167,7 +166,7 @@ private class ReturnTypeCalculatorWithJump(
         return when (val status = implicitBodyResolveComputationSession.getStatus(declaration.symbol)) {
             is ImplicitBodyResolveComputationStatus.Computed -> status.resolvedTypeRef
             is ImplicitBodyResolveComputationStatus.Computing ->
-                FirErrorTypeRefImpl(null, FirSimpleDiagnostic("cycle", DiagnosticKind.RecursionInImplicitTypes))
+                buildErrorTypeRef {diagnostic = FirSimpleDiagnostic("cycle", DiagnosticKind.RecursionInImplicitTypes) }
             else -> computeReturnTypeRef(declaration)
         }
     }
@@ -185,13 +184,12 @@ private class ReturnTypeCalculatorWithJump(
         }.mapTo(mutableListOf()) { provider.getFirClassifierByFqName(it) }
 
         if (file == null || outerClasses.any { it == null }) {
-            return FirErrorTypeRefImpl(
-                null,
-                FirSimpleDiagnostic(
+            return buildErrorTypeRef {
+                diagnostic = FirSimpleDiagnostic(
                     "Cannot calculate return type (local class/object?)",
                     DiagnosticKind.InferenceError
                 )
-            )
+            }
         }
         val designation = (listOf(file) + outerClasses.filterNotNull().asReversed() + listOf(declaration))
         val transformer = FirDesignatedBodyResolveTransformerForReturnTypeCalculator(

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/AbstractFirUseSiteMemberScope.kt

@@ -9,6 +9,9 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.builder.FirSimpleFunctionBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.FirValueParameterBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -82,41 +85,40 @@ abstract class AbstractFirUseSiteMemberScope(
                     if (overriddenParameter.defaultValue != null)
                         createValueParameterCopy(overrideParameter, overriddenParameter.defaultValue).apply {
                             annotations += overrideParameter.annotations
-                        }
+                        }.build()
                     else
                         overrideParameter
                 }
-        }
+        }.build()
 
         return newSymbol
     }
 
-    protected open fun createFunctionCopy(firSimpleFunction: FirSimpleFunction, newSymbol: FirNamedFunctionSymbol): FirSimpleFunctionImpl =
-        FirSimpleFunctionImpl(
-            firSimpleFunction.source,
-            firSimpleFunction.session,
-            firSimpleFunction.returnTypeRef,
-            firSimpleFunction.receiverTypeRef,
-            firSimpleFunction.status,
-            firSimpleFunction.name,
-            newSymbol
-        )
-
-    protected open fun createValueParameterCopy(parameter: FirValueParameter, newDefaultValue: FirExpression?): FirValueParameterImpl =
-        with(parameter) {
-            FirValueParameterImpl(
-                source,
-                session,
-                returnTypeRef,
-                name,
-                FirVariableSymbol(parameter.symbol.callableId),
-                newDefaultValue,
-                isCrossinline,
-                isNoinline,
-                isVararg
-            )
+    protected open fun createFunctionCopy(firSimpleFunction: FirSimpleFunction, newSymbol: FirNamedFunctionSymbol): FirSimpleFunctionBuilder =
+        FirSimpleFunctionBuilder().apply {
+            source = firSimpleFunction.source
+            session = firSimpleFunction.session
+            returnTypeRef = firSimpleFunction.returnTypeRef
+            receiverTypeRef = firSimpleFunction.receiverTypeRef
+            name = firSimpleFunction.name
+            status = firSimpleFunction.status
+            symbol = newSymbol
         }
 
+    protected open fun createValueParameterCopy(parameter: FirValueParameter, newDefaultValue: FirExpression?): FirValueParameterBuilder =
+        FirValueParameterBuilder().apply {
+            source = parameter.source
+            session = parameter.session
+            returnTypeRef = parameter.returnTypeRef
+            name = parameter.name
+            symbol = FirVariableSymbol(parameter.symbol.callableId)
+            defaultValue = newDefaultValue
+            isCrossinline = parameter.isCrossinline
+            isNoinline = parameter.isNoinline
+            isVararg = parameter.isVararg
+        }
+
+
     override fun processClassifiersByName(
         name: Name,
         processor: (FirClassifierSymbol<*>) -> Unit

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractSimpleImportingScope.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
+import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel
@@ -20,7 +20,7 @@ abstract class FirAbstractSimpleImportingScope(
     scopeSession: ScopeSession
 ) : FirAbstractImportingScope(session, scopeSession, lookupInFir = true) {
 
-    protected abstract val simpleImports: Map<Name, List<FirResolvedImportImpl>>
+    protected abstract val simpleImports: Map<Name, List<FirResolvedImport>>
 
     override fun processClassifiersByName(
         name: Name,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.FirField
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.fir.declarations.impl.*
+import org.jetbrains.kotlin.fir.declarations.builder.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.substitution.ChainedSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -22,9 +22,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.name.Name
 
 class FirClassSubstitutionScope(
@@ -127,10 +127,13 @@ class FirClassSubstitutionScope(
     ): Pair<List<FirTypeParameter>, ConeSubstitutor> {
         if (member.typeParameters.isEmpty()) return Pair(member.typeParameters, substitutor)
         val newTypeParameters = member.typeParameters.map { originalParameter ->
-            FirTypeParameterImpl(
-                originalParameter.source, originalParameter.session, originalParameter.name,
-                FirTypeParameterSymbol(), originalParameter.variance, originalParameter.isReified
-            ).apply {
+            FirTypeParameterBuilder().apply {
+                source = originalParameter.source
+                session = originalParameter.session
+                name = originalParameter.name
+                symbol = FirTypeParameterSymbol()
+                variance = originalParameter.variance
+                isReified = originalParameter.isReified
                 annotations += originalParameter.annotations
             }
         }
@@ -151,9 +154,10 @@ class FirClassSubstitutionScope(
                 }
 
                 newTypeParameter.bounds +=
-                    FirResolvedTypeRefImpl(
-                        boundTypeRef.source, additionalSubstitutor.substituteOrSelf(substitutedBound ?: typeForBound)
-                    )
+                    buildResolvedTypeRef {
+                        source = boundTypeRef.source
+                        type = additionalSubstitutor.substituteOrSelf(substitutedBound ?: typeForBound)
+                    }
             }
         }
 
@@ -162,7 +166,7 @@ class FirClassSubstitutionScope(
         // While common Ir contracts expect them to be different
         // if (!wereChangesInTypeParameters) return Pair(member.typeParameters, substitutor)
 
-        return Pair(newTypeParameters, ChainedSubstitutor(substitutor, additionalSubstitutor))
+        return Pair(newTypeParameters.map { it.build() }, ChainedSubstitutor(substitutor, additionalSubstitutor))
     }
 
     private fun createFakeOverrideProperty(original: FirPropertySymbol): FirPropertySymbol {
@@ -217,47 +221,43 @@ class FirClassSubstitutionScope(
             newParameterTypes: List<ConeKotlinType?>? = null,
             newTypeParameters: List<FirTypeParameter>? = null
         ): FirSimpleFunction {
-            return with(baseFunction) {
-                // TODO: consider using here some light-weight functions instead of pseudo-real FirMemberFunctionImpl
-                // As second alternative, we can invent some light-weight kind of FirRegularClass
-                FirSimpleFunctionImpl(
-                    source,
-                    session,
-                    baseFunction.returnTypeRef.withReplacedReturnType(newReturnType),
-                    baseFunction.receiverTypeRef?.withReplacedConeType(newReceiverType),
-                    baseFunction.status,
-                    name,
-                    fakeOverrideSymbol
-                ).apply {
-                    annotations += baseFunction.annotations
-                    resolvePhase = baseFunction.resolvePhase
-                    valueParameters += baseFunction.valueParameters.zip(
-                        newParameterTypes ?: List(baseFunction.valueParameters.size) { null }
-                    ) { valueParameter, newType ->
-                        with(valueParameter) {
-                            FirValueParameterImpl(
-                                source,
-                                session,
-                                this.returnTypeRef.withReplacedConeType(newType),
-                                name,
-                                FirVariableSymbol(valueParameter.symbol.callableId),
-                                defaultValue,
-                                isCrossinline,
-                                isNoinline,
-                                isVararg
-                            )
-                        }
-                    }
-
-                    // TODO: Fix the hack for org.jetbrains.kotlin.fir.backend.Fir2IrVisitor.addFakeOverrides
-                    // We might have added baseFunction.typeParameters in case new ones are null
-                    // But it fails at org.jetbrains.kotlin.ir.AbstractIrTextTestCase.IrVerifier.elementsAreUniqueChecker
-                    // because it shares the same declarations of type parameters between two different two functions
-                    if (newTypeParameters != null) {
-                        typeParameters += newTypeParameters
+            // TODO: consider using here some light-weight functions instead of pseudo-real FirMemberFunctionImpl
+            // As second alternative, we can invent some light-weight kind of FirRegularClass
+            return buildSimpleFunction {
+                source = baseFunction.source
+                this.session = session
+                returnTypeRef = baseFunction.returnTypeRef.withReplacedReturnType(newReturnType)
+                receiverTypeRef = baseFunction.receiverTypeRef?.withReplacedConeType(newReceiverType)
+                name = baseFunction.name
+                status = baseFunction.status
+                symbol = fakeOverrideSymbol
+                annotations += baseFunction.annotations
+                resolvePhase = baseFunction.resolvePhase
+                valueParameters += baseFunction.valueParameters.zip(
+                    newParameterTypes ?: List(baseFunction.valueParameters.size) { null }
+                ) { valueParameter, newType ->
+                    buildValueParameter {
+                        source = valueParameter.source
+                        this.session = session
+                        returnTypeRef = valueParameter.returnTypeRef.withReplacedConeType(newType)
+                        name = valueParameter.name
+                        symbol = FirVariableSymbol(valueParameter.symbol.callableId)
+                        defaultValue = valueParameter.defaultValue
+                        isCrossinline = valueParameter.isCrossinline
+                        isNoinline = valueParameter.isNoinline
+                        isVararg = valueParameter.isVararg
                     }
                 }
+
+                // TODO: Fix the hack for org.jetbrains.kotlin.fir.backend.Fir2IrVisitor.addFakeOverrides
+                // We might have added baseFunction.typeParameters in case new ones are null
+                // But it fails at org.jetbrains.kotlin.ir.AbstractIrTextTestCase.IrVerifier.elementsAreUniqueChecker
+                // because it shares the same declarations of type parameters between two different two functions
+                if (newTypeParameters != null) {
+                    typeParameters += newTypeParameters
+                }
             }
+
         }
 
         fun createFakeOverrideFunction(
@@ -284,23 +284,18 @@ class FirClassSubstitutionScope(
             newReturnType: ConeKotlinType? = null
         ): FirPropertySymbol {
             val symbol = FirPropertySymbol(baseSymbol.callableId, true, baseSymbol)
-            with(baseProperty) {
-                FirPropertyImpl(
-                    source,
-                    session,
-                    baseProperty.returnTypeRef.withReplacedReturnType(newReturnType),
-                    baseProperty.receiverTypeRef?.withReplacedConeType(newReceiverType),
-                    name,
-                    null,
-                    null,
-                    isVar,
-                    symbol,
-                    false,
-                    baseProperty.status
-                ).apply {
-                    resolvePhase = baseProperty.resolvePhase
-                    annotations += baseProperty.annotations
-                }
+            buildProperty {
+                source = baseProperty.source
+                this.session = session
+                returnTypeRef = baseProperty.returnTypeRef.withReplacedReturnType(newReturnType)
+                receiverTypeRef = baseProperty.receiverTypeRef?.withReplacedConeType(newReceiverType)
+                name = baseProperty.name
+                isVar = baseProperty.isVar
+                this.symbol = symbol
+                isLocal = false
+                status = baseProperty.status
+                resolvePhase = baseProperty.resolvePhase
+                annotations += baseProperty.annotations
             }
             return symbol
         }
@@ -312,15 +307,16 @@ class FirClassSubstitutionScope(
             newReturnType: ConeKotlinType? = null
         ): FirFieldSymbol {
             val symbol = FirFieldSymbol(baseSymbol.callableId)
-            with(baseField) {
-                FirFieldImpl(
-                    source, session,
-                    baseField.returnTypeRef.withReplacedConeType(newReturnType),
-                    name, symbol, isVar, baseField.status
-                ).apply {
-                    resolvePhase = baseField.resolvePhase
-                    annotations += baseField.annotations
-                }
+            buildField {
+                source = baseField.source
+                this.session = session
+                returnTypeRef = baseField.returnTypeRef.withReplacedConeType(newReturnType)
+                name = baseField.name
+                this.symbol = symbol
+                isVar = baseField.isVar
+                status = baseField.status
+                resolvePhase = baseField.resolvePhase
+                annotations += baseField.annotations
             }
             return symbol
         }
@@ -345,7 +341,9 @@ fun FirTypeRef.withReplacedReturnType(newType: ConeKotlinType?): FirTypeRef {
     require(this is FirResolvedTypeRef || newType == null)
     if (newType == null) return this
 
-    return FirResolvedTypeRefImpl(source, newType).apply {
+    return buildResolvedTypeRef {
+        source = this@withReplacedReturnType.source
+        type = newType
         annotations += this@withReplacedReturnType.annotations
     }
 }
@@ -354,7 +352,9 @@ fun FirTypeRef.withReplacedConeType(newType: ConeKotlinType?): FirResolvedTypeRe
     require(this is FirResolvedTypeRef)
     if (newType == null) return this
 
-    return FirResolvedTypeRefImpl(source, newType).apply {
+    return buildResolvedTypeRef {
+        source = this@withReplacedConeType.source
+        type = newType
         annotations += this@withReplacedConeType.annotations
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt

@@ -7,8 +7,9 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.impl.FirImportImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
+import org.jetbrains.kotlin.fir.declarations.FirImport
+import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
+import org.jetbrains.kotlin.fir.declarations.builder.buildImport
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer
 
@@ -18,8 +19,8 @@ class FirDefaultSimpleImportingScope(
     priority: DefaultImportPriority
 ) : FirAbstractSimpleImportingScope(session, scopeSession) {
 
-    private fun FirImportImpl.resolve(importResolveTransformer: FirImportResolveTransformer) =
-        importResolveTransformer.transformImport(this, null).single as FirResolvedImportImpl
+    private fun FirImport.resolve(importResolveTransformer: FirImportResolveTransformer) =
+        importResolveTransformer.transformImport(this, null).single as FirResolvedImport
 
     override val simpleImports = run {
         val importResolveTransformer = FirImportResolveTransformer(session)
@@ -28,8 +29,10 @@ class FirDefaultSimpleImportingScope(
         allDefaultImports
             ?.filter { !it.isAllUnder }
             ?.map {
-                FirImportImpl(null, it.fqName, isAllUnder = false, aliasName = null)
-                    .resolve(importResolveTransformer)
+                buildImport {
+                    importedFqName = it.fqName
+                    isAllUnder = false
+                }.resolve(importResolveTransformer)
             }?.groupBy { it.importedName!! } ?: emptyMap()
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultStarImportingScope.kt

@@ -7,8 +7,8 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.impl.FirImportImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
+import org.jetbrains.kotlin.fir.declarations.builder.buildImport
+import org.jetbrains.kotlin.fir.declarations.builder.buildResolvedImport
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 
 class FirDefaultStarImportingScope(
@@ -24,11 +24,13 @@ class FirDefaultStarImportingScope(
         allDefaultImports
             ?.filter { it.isAllUnder }
             ?.map {
-                FirResolvedImportImpl(
-                    FirImportImpl(null, it.fqName, isAllUnder = true, aliasName = null),
-                    it.fqName,
-                    null
-                )
+                buildResolvedImport {
+                    delegate = buildImport {
+                        importedFqName = it.fqName
+                        isAllUnder = true
+                    }
+                    packageFqName = it.fqName
+                }
             } ?: emptyList()
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirExplicitSimpleImportingScope.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirImport
-import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
+import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 
 class FirExplicitSimpleImportingScope(
@@ -17,7 +17,7 @@ class FirExplicitSimpleImportingScope(
 ) : FirAbstractSimpleImportingScope(session, scopeSession) {
 
     override val simpleImports =
-        imports.filterIsInstance<FirResolvedImportImpl>()
+        imports.filterIsInstance<FirResolvedImport>()
             .filter { !it.isAllUnder && it.importedName != null }
             .groupBy { it.aliasName ?: it.importedName!! }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirIntegerLiteralTypeScope.kt

@@ -7,19 +7,15 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.FirSymbolOwner
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
 import org.jetbrains.kotlin.fir.resolve.scopeSessionKey
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
@@ -80,17 +76,17 @@ class FirIntegerLiteralTypeScope(private val session: FirSession) : FirScope() {
         name to FirNamedFunctionSymbol(CallableId(name)).apply {
             createFirFunction(name, this).apply {
                 val valueParameterName = Name.identifier("arg")
-                valueParameters += FirValueParameterImpl(
-                    source = null,
-                    session,
-                    FirILTTypeRefPlaceHolder(),
-                    valueParameterName,
-                    FirVariableSymbol(name),
-                    defaultValue = null,
-                    isCrossinline = false,
-                    isNoinline = false,
+                valueParameters += buildValueParameter {
+                    source = null
+                    session = this@FirIntegerLiteralTypeScope.session
+                    returnTypeRef = FirILTTypeRefPlaceHolder()
+                    this.name = valueParameterName
+                    symbol = FirVariableSymbol(valueParameterName)
+                    defaultValue = null
+                    isCrossinline = false
+                    isNoinline = false
                     isVararg = false
-                )
+                }
             }
         }
     }.toMap()
@@ -99,6 +95,7 @@ class FirIntegerLiteralTypeScope(private val session: FirSession) : FirScope() {
         name to FirNamedFunctionSymbol(CallableId(name)).apply { createFirFunction(name, this) }
     }.toMap()
 
+    @UseExperimental(FirImplementationDetail::class)
     private fun createFirFunction(name: Name, symbol: FirNamedFunctionSymbol): FirSimpleFunctionImpl = FirIntegerOperator(
         source = null,
         session,
@@ -126,7 +123,8 @@ class FirIntegerLiteralTypeScope(private val session: FirSession) : FirScope() {
     }
 }
 
-class FirIntegerOperator(
+@UseExperimental(FirImplementationDetail::class)
+class FirIntegerOperator @FirImplementationDetail constructor(
     source: FirSourceElement?,
     session: FirSession,
     returnTypeRef: FirTypeRef,
@@ -134,7 +132,21 @@ class FirIntegerOperator(
     val kind: Kind,
     status: FirDeclarationStatus,
     symbol: FirFunctionSymbol<FirSimpleFunction>
-) : FirSimpleFunctionImpl(source, session, returnTypeRef, receiverTypeRef, status, kind.operatorName, symbol) {
+) : FirSimpleFunctionImpl(
+    source,
+    session,
+    resolvePhase = FirResolvePhase.BODY_RESOLVE,
+    returnTypeRef,
+    receiverTypeRef,
+    typeParameters = mutableListOf(),
+    valueParameters = mutableListOf(),
+    body = null,
+    status,
+    containerSource = null,
+    kind.operatorName,
+    symbol,
+    annotations = mutableListOf(),
+) {
     enum class Kind(val unary: Boolean, val operatorName: Name) {
         PLUS(false, OperatorNameConventions.PLUS),
         MINUS(false, OperatorNameConventions.MINUS),
@@ -166,4 +178,3 @@ class FirILTTypeRefPlaceHolder : FirResolvedTypeRef() {
     }
 }
 
-class FirIntegerOperatorCall(source: FirSourceElement?) : FirFunctionCallImpl(source)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirIntegerOperatorCall.kt

@@ -0,0 +1,83 @@
+/*
+ * 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.fir.scopes.impl
+
+import org.jetbrains.kotlin.fir.FirImplementationDetail
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
+import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder
+import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
+import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessBuilder
+import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
+import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
+import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.types.FirTypeProjection
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
+
+@UseExperimental(FirImplementationDetail::class)
+class FirIntegerOperatorCall @FirImplementationDetail constructor(
+    source: FirSourceElement?,
+    typeRef: FirTypeRef,
+    annotations: MutableList<FirAnnotationCall>,
+    safe: Boolean,
+    typeArguments: MutableList<FirTypeProjection>,
+    explicitReceiver: FirExpression?,
+    dispatchReceiver: FirExpression,
+    extensionReceiver: FirExpression,
+    arguments: MutableList<FirExpression>,
+    calleeReference: FirNamedReference,
+) : FirFunctionCallImpl(
+    source,
+    typeRef,
+    annotations,
+    safe,
+    typeArguments,
+    explicitReceiver,
+    dispatchReceiver,
+    extensionReceiver,
+    arguments,
+    calleeReference,
+)
+
+@FirBuilderDsl
+class FirIntegerOperatorCallBuilder : FirQualifiedAccessBuilder, FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder {
+    override var source: FirSourceElement? = null
+    override var typeRef: FirTypeRef = buildImplicitTypeRef()
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    override var safe: Boolean = false
+    override val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
+    override var explicitReceiver: FirExpression? = null
+    override var dispatchReceiver: FirExpression = FirNoReceiverExpression
+    override var extensionReceiver: FirExpression = FirNoReceiverExpression
+    override val arguments: MutableList<FirExpression> = mutableListOf()
+    lateinit var calleeReference: FirNamedReference
+
+    @UseExperimental(FirImplementationDetail::class)
+    override fun build(): FirIntegerOperatorCall {
+        return FirIntegerOperatorCall(
+            source,
+            typeRef,
+            annotations,
+            safe,
+            typeArguments,
+            explicitReceiver,
+            dispatchReceiver,
+            extensionReceiver,
+            arguments,
+            calleeReference,
+        )
+    }
+
+}
+
+inline fun buildFunctionCall(init: FirIntegerOperatorCallBuilder.() -> Unit): FirIntegerOperatorCall {
+    return FirIntegerOperatorCallBuilder().apply(init).build()
+}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/jvm/FirJavaTypeRef.kt

@@ -5,15 +5,43 @@
 
 package org.jetbrains.kotlin.fir.types.jvm
 
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.types.FirQualifierPart
+import org.jetbrains.kotlin.fir.types.FirUserTypeRef
+import org.jetbrains.kotlin.fir.types.builder.FirUserTypeRefBuilder
 import org.jetbrains.kotlin.fir.types.impl.FirUserTypeRefImpl
 import org.jetbrains.kotlin.load.java.structure.JavaType
 
 class FirJavaTypeRef(
-    annotations: List<FirAnnotationCall>,
-    val type: JavaType
-) : FirUserTypeRefImpl(source = null, isMarkedNullable = false) {
-    init {
-        this.annotations += annotations
+    val type: JavaType,
+    annotations: MutableList<FirAnnotationCall>,
+    qualifier: MutableList<FirQualifierPart>
+) : FirUserTypeRefImpl(
+    source = null,
+    isMarkedNullable = false,
+    qualifier,
+    annotations
+)
+
+@FirBuilderDsl
+class FirJavaTypeRefBuilder : FirUserTypeRefBuilder() {
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    lateinit var type: JavaType
+
+    override fun build(): FirJavaTypeRef {
+        return FirJavaTypeRef(type, annotations, qualifier)
     }
+
+    @Deprecated("Modification of 'source' has no impact for FirJavaTypeRefBuilder", level = DeprecationLevel.HIDDEN)
+    override var source: FirSourceElement? = null
+
+    @Deprecated("Modification of 'isMarkedNullable' has no impact for FirJavaTypeRefBuilder", level = DeprecationLevel.HIDDEN)
+    override var isMarkedNullable: Boolean = false
+}
+
+inline fun buildJavaTypeRef(init: FirJavaTypeRefBuilder.() -> Unit): FirJavaTypeRef {
+    return FirJavaTypeRefBuilder().apply(init).build()
 }

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt

@@ -102,7 +102,7 @@ class FirResolveBench(val withProgress: Boolean) {
             var firFile: FirFile? = null
             val time = measureNanoTime {
                 firFile = builder.buildFirFile(file)
-                (builder.session.firProvider as FirProviderImpl).recordFile(firFile!!)
+                (builder.baseSession.firProvider as FirProviderImpl).recordFile(firFile!!)
             }
             val after = vmStateSnapshot()
             val diff = after - before

compiler/fir/tree/build.gradle.kts

@@ -28,7 +28,7 @@ dependencies {
     generatorClasspath(project("tree-generator"))
 }
 
-val generationRoot = projectDir.resolve("gen")
+val generationRoot = File(projectDir.resolve("gen").absolutePath.replace("tree", "new-tree"))
 
 val generateTree by tasks.registering(NoDebugJavaExec::class) {
 

compiler/fir/tree/gen/.gitattributes

@@ -1 +0,0 @@
-*.kt eol=lf

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/builder/FirAbstractAnnotatedElementBuilder.kt

@@ -0,0 +1,42 @@
+/*
+ * 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.fir.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.fir.FirAnnotationContainer
+import org.jetbrains.kotlin.fir.FirPureAbstractElement
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirAbstractAnnotatedElementBuilder {
+    var source: FirSourceElement? = null
+    val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+
+    fun build(): FirAnnotationContainer {
+        return FirAbstractAnnotatedElement(
+            source,
+            annotations,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildAbstractAnnotatedElement(init: FirAbstractAnnotatedElementBuilder.() -> Unit = {}): FirAnnotationContainer {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirAbstractAnnotatedElementBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/builder/FirAnnotationContainerBuilder.kt

@@ -0,0 +1,25 @@
+/*
+ * 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.fir.builder
+
+import org.jetbrains.kotlin.fir.FirAnnotationContainer
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+interface FirAnnotationContainerBuilder {
+    abstract var source: FirSourceElement?
+    abstract val annotations: MutableList<FirAnnotationCall>
+
+    fun build(): FirAnnotationContainer
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/builder/FirLabelBuilder.kt

@@ -0,0 +1,40 @@
+/*
+ * 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.fir.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.fir.FirLabel
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.impl.FirLabelImpl
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirLabelBuilder {
+    var source: FirSourceElement? = null
+    lateinit var name: String
+
+    fun build(): FirLabel {
+        return FirLabelImpl(
+            source,
+            name,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildLabel(init: FirLabelBuilder.() -> Unit): FirLabel {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirLabelBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/contracts/builder/FirContractDescriptionBuilder.kt

@@ -0,0 +1,41 @@
+/*
+ * 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.fir.contracts.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.contracts.FirContractDescription
+import org.jetbrains.kotlin.fir.contracts.description.ConeEffectDeclaration
+import org.jetbrains.kotlin.fir.contracts.impl.FirContractDescriptionImpl
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirContractDescriptionBuilder {
+    var source: FirSourceElement? = null
+    val effects: MutableList<ConeEffectDeclaration> = mutableListOf()
+
+    fun build(): FirContractDescription {
+        return FirContractDescriptionImpl(
+            source,
+            effects,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildContractDescription(init: FirContractDescriptionBuilder.() -> Unit = {}): FirContractDescription {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirContractDescriptionBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/contracts/impl/FirContractDescriptionImpl.kt

@@ -15,11 +15,10 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-class FirContractDescriptionImpl(
-    override val source: FirSourceElement?
+internal class FirContractDescriptionImpl(
+    override val source: FirSourceElement?,
+    override val effects: MutableList<ConeEffectDeclaration>,
 ) : FirContractDescription() {
-    override val effects: MutableList<ConeEffectDeclaration> = mutableListOf()
-
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirContractDescriptionImpl {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirContractDescriptionOwner.kt

@@ -21,5 +21,7 @@ interface FirContractDescriptionOwner : FirElement {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitContractDescriptionOwner(this, data)
 
+    fun replaceContractDescription(newContractDescription: FirContractDescription)
+
     fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirContractDescriptionOwner
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt

@@ -33,6 +33,7 @@ interface FirRegularClass : FirMemberDeclaration, FirTypeParametersOwner, FirCla
     val name: Name
     override val symbol: FirRegularClassSymbol
     val companionObject: FirRegularClass?
+    val hasLazyNestedClassifiers: Boolean
     override val superTypeRefs: List<FirTypeRef>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitRegularClass(this, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirSealedClass.kt

@@ -35,6 +35,7 @@ abstract class FirSealedClass : FirPureAbstractElement(), FirRegularClass {
     abstract override val name: Name
     abstract override val symbol: FirRegularClassSymbol
     abstract override val companionObject: FirRegularClass?
+    abstract override val hasLazyNestedClassifiers: Boolean
     abstract override val superTypeRefs: List<FirTypeRef>
     abstract val inheritors: List<ClassId>
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/AbstractFirRegularClassBuilder.kt

@@ -0,0 +1,48 @@
+/*
+ * 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.fir.declarations.builder
+
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.builder.FirClassBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParametersOwnerBuilder
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.name.Name
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+interface AbstractFirRegularClassBuilder : FirClassBuilder, FirTypeParametersOwnerBuilder {
+    abstract override var source: FirSourceElement?
+    abstract override val annotations: MutableList<FirAnnotationCall>
+    abstract override var session: FirSession
+    abstract override var classKind: ClassKind
+    abstract override val superTypeRefs: MutableList<FirTypeRef>
+    abstract override val declarations: MutableList<FirDeclaration>
+    abstract override var scopeProvider: FirScopeProvider
+    abstract override val typeParameters: MutableList<FirTypeParameter>
+    abstract var resolvePhase: FirResolvePhase
+    abstract var status: FirDeclarationStatus
+    abstract var name: Name
+    abstract var symbol: FirRegularClassSymbol
+    abstract var companionObject: FirRegularClass?
+    abstract var hasLazyNestedClassifiers: Boolean
+    override fun build(): FirRegularClass
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAbstractConstructorBuilder.kt

@@ -0,0 +1,48 @@
+/*
+ * 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.fir.declarations.builder
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.builder.FirFunctionBuilder
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
+import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+interface FirAbstractConstructorBuilder : FirFunctionBuilder {
+    abstract override var source: FirSourceElement?
+    abstract override val annotations: MutableList<FirAnnotationCall>
+    abstract override var session: FirSession
+    abstract override var returnTypeRef: FirTypeRef
+    abstract override val typeParameters: MutableList<FirTypeParameter>
+    abstract override val valueParameters: MutableList<FirValueParameter>
+    abstract override var body: FirBlock?
+    abstract var resolvePhase: FirResolvePhase
+    abstract var receiverTypeRef: FirTypeRef?
+    abstract var controlFlowGraphReference: FirControlFlowGraphReference
+    abstract var status: FirDeclarationStatus
+    abstract var containerSource: DeserializedContainerSource?
+    abstract var symbol: FirConstructorSymbol
+    abstract var delegatedConstructor: FirDelegatedConstructorCall?
+    override fun build(): FirConstructor
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousFunctionBuilder.kt

@@ -0,0 +1,81 @@
+/*
+ * 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.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.contracts.description.InvocationKind
+import org.jetbrains.kotlin.fir.FirLabel
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.builder.FirFunctionBuilder
+import org.jetbrains.kotlin.fir.declarations.impl.FirAnonymousFunctionImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableFunction
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
+import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
+import org.jetbrains.kotlin.fir.references.impl.FirEmptyControlFlowGraphReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirAnonymousFunctionBuilder : FirFunctionBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder {
+    override var source: FirSourceElement? = null
+    override lateinit var session: FirSession
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    override lateinit var returnTypeRef: FirTypeRef
+    var receiverTypeRef: FirTypeRef? = null
+    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
+    var controlFlowGraphReference: FirControlFlowGraphReference = FirEmptyControlFlowGraphReference
+    override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
+    override var body: FirBlock? = null
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
+    lateinit var symbol: FirAnonymousFunctionSymbol
+    var label: FirLabel? = null
+    var invocationKind: InvocationKind? = null
+    var isLambda: Boolean by kotlin.properties.Delegates.notNull<Boolean>()
+
+    override fun build(): FirAnonymousFunction {
+        return FirAnonymousFunctionImpl(
+            source,
+            session,
+            annotations,
+            returnTypeRef,
+            receiverTypeRef,
+            typeParameters,
+            controlFlowGraphReference,
+            valueParameters,
+            body,
+            typeRef,
+            symbol,
+            label,
+            invocationKind,
+            isLambda,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildAnonymousFunction(init: FirAnonymousFunctionBuilder.() -> Unit): FirAnonymousFunction {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirAnonymousFunctionBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousInitializerBuilder.kt

@@ -0,0 +1,47 @@
+/*
+ * 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.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.impl.FirAnonymousInitializerImpl
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirAnonymousInitializerBuilder {
+    var source: FirSourceElement? = null
+    lateinit var session: FirSession
+    var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    var body: FirBlock? = null
+
+    fun build(): FirAnonymousInitializer {
+        return FirAnonymousInitializerImpl(
+            source,
+            session,
+            resolvePhase,
+            body,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildAnonymousInitializer(init: FirAnonymousInitializerBuilder.() -> Unit): FirAnonymousInitializer {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirAnonymousInitializerBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousObjectBuilder.kt

@@ -0,0 +1,69 @@
+/*
+ * 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.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.builder.FirClassBuilder
+import org.jetbrains.kotlin.fir.declarations.impl.FirAnonymousObjectImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
+import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirAnonymousObjectBuilder : FirClassBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder {
+    override var source: FirSourceElement? = null
+    override lateinit var session: FirSession
+    var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    override lateinit var classKind: ClassKind
+    override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()
+    override val declarations: MutableList<FirDeclaration> = mutableListOf()
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    override lateinit var scopeProvider: FirScopeProvider
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
+    lateinit var symbol: FirAnonymousObjectSymbol
+
+    override fun build(): FirAnonymousObject {
+        return FirAnonymousObjectImpl(
+            source,
+            session,
+            resolvePhase,
+            classKind,
+            superTypeRefs,
+            declarations,
+            annotations,
+            scopeProvider,
+            typeRef,
+            symbol,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildAnonymousObject(init: FirAnonymousObjectBuilder.() -> Unit): FirAnonymousObject {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirAnonymousObjectBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirClassBuilder.kt

@@ -0,0 +1,35 @@
+/*
+ * 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.fir.declarations.builder
+
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+interface FirClassBuilder : FirAnnotationContainerBuilder {
+    abstract override var source: FirSourceElement?
+    abstract override val annotations: MutableList<FirAnnotationCall>
+    abstract var session: FirSession
+    abstract var classKind: ClassKind
+    abstract val superTypeRefs: MutableList<FirTypeRef>
+    abstract val declarations: MutableList<FirDeclaration>
+    abstract var scopeProvider: FirScopeProvider
+    override fun build(): FirClass<*>
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirClassImplBuilder.kt

@@ -0,0 +1,84 @@
+/*
+ * 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.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.FirPureAbstractElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.builder.AbstractFirRegularClassBuilder
+import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableRegularClass
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.name.Name
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+open class FirClassImplBuilder : AbstractFirRegularClassBuilder, FirAnnotationContainerBuilder {
+    override var source: FirSourceElement? = null
+    override lateinit var session: FirSession
+    override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
+    override lateinit var status: FirDeclarationStatus
+    override lateinit var classKind: ClassKind
+    override val declarations: MutableList<FirDeclaration> = mutableListOf()
+    override lateinit var scopeProvider: FirScopeProvider
+    override lateinit var name: Name
+    override lateinit var symbol: FirRegularClassSymbol
+    override var companionObject: FirRegularClass? = null
+    override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()
+
+    override fun build(): FirRegularClass {
+        return FirClassImpl(
+            source,
+            session,
+            resolvePhase,
+            annotations,
+            typeParameters,
+            status,
+            classKind,
+            declarations,
+            scopeProvider,
+            name,
+            symbol,
+            companionObject,
+            superTypeRefs,
+        )
+    }
+
+
+    @Deprecated("Modification of 'hasLazyNestedClassifiers' has no impact for FirClassImplBuilder", level = DeprecationLevel.HIDDEN)
+    override var hasLazyNestedClassifiers: Boolean
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildClassImpl(init: FirClassImplBuilder.() -> Unit): FirRegularClass {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirClassImplBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirConstructorBuilder.kt

@@ -0,0 +1,85 @@
+/*
+ * 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.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.builder.FirAbstractConstructorBuilder
+import org.jetbrains.kotlin.fir.declarations.impl.FirConstructorImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableConstructor
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
+import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
+import org.jetbrains.kotlin.fir.references.impl.FirEmptyControlFlowGraphReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+open class FirConstructorBuilder : FirAbstractConstructorBuilder, FirAnnotationContainerBuilder {
+    override var source: FirSourceElement? = null
+    override lateinit var session: FirSession
+    override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    override lateinit var returnTypeRef: FirTypeRef
+    override var receiverTypeRef: FirTypeRef? = null
+    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
+    override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
+    override lateinit var status: FirDeclarationStatus
+    override var containerSource: DeserializedContainerSource? = null
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    override lateinit var symbol: FirConstructorSymbol
+    override var delegatedConstructor: FirDelegatedConstructorCall? = null
+    override var body: FirBlock? = null
+
+    override fun build(): FirConstructor {
+        return FirConstructorImpl(
+            source,
+            session,
+            resolvePhase,
+            returnTypeRef,
+            receiverTypeRef,
+            typeParameters,
+            valueParameters,
+            status,
+            containerSource,
+            annotations,
+            symbol,
+            delegatedConstructor,
+            body,
+        )
+    }
+
+
+    @Deprecated("Modification of 'controlFlowGraphReference' has no impact for FirConstructorBuilder", level = DeprecationLevel.HIDDEN)
+    override var controlFlowGraphReference: FirControlFlowGraphReference
+        get() = throw IllegalStateException()
+        set(value) {
+            throw IllegalStateException()
+        }
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildConstructor(init: FirConstructorBuilder.() -> Unit): FirConstructor {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirConstructorBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirDefaultSetterValueParameterBuilder.kt

@@ -0,0 +1,82 @@
+/*
+ * 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.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultSetterValueParameter
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.name.Name
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirDefaultSetterValueParameterBuilder : FirAnnotationContainerBuilder {
+    override var source: FirSourceElement? = null
+    lateinit var session: FirSession
+    var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    lateinit var returnTypeRef: FirTypeRef
+    var receiverTypeRef: FirTypeRef? = null
+    lateinit var symbol: FirVariableSymbol<FirValueParameter>
+    var initializer: FirExpression? = null
+    var delegate: FirExpression? = null
+    var delegateFieldSymbol: FirDelegateFieldSymbol<FirValueParameter>? = null
+    var isVar: Boolean = false
+    var isVal: Boolean = true
+    var getter: FirPropertyAccessor? = null
+    var setter: FirPropertyAccessor? = null
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    var defaultValue: FirExpression? = null
+    var isCrossinline: Boolean = false
+    var isNoinline: Boolean = false
+    var isVararg: Boolean = false
+
+    override fun build(): FirValueParameter {
+        return FirDefaultSetterValueParameter(
+            source,
+            session,
+            resolvePhase,
+            returnTypeRef,
+            receiverTypeRef,
+            symbol,
+            initializer,
+            delegate,
+            delegateFieldSymbol,
+            isVar,
+            isVal,
+            getter,
+            setter,
+            annotations,
+            defaultValue,
+            isCrossinline,
+            isNoinline,
+            isVararg,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildDefaultSetterValueParameter(init: FirDefaultSetterValueParameterBuilder.() -> Unit): FirValueParameter {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirDefaultSetterValueParameterBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirEnumEntryBuilder.kt

@@ -0,0 +1,71 @@
+/*
+ * 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.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
+import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirEnumEntryImpl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirEnumEntryBuilder : FirAnnotationContainerBuilder {
+    override var source: FirSourceElement? = null
+    lateinit var session: FirSession
+    var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    lateinit var returnTypeRef: FirTypeRef
+    lateinit var name: Name
+    lateinit var symbol: FirVariableSymbol<FirEnumEntry>
+    var initializer: FirExpression? = null
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
+    lateinit var status: FirDeclarationStatus
+    var containerSource: DeserializedContainerSource? = null
+
+    override fun build(): FirEnumEntry {
+        return FirEnumEntryImpl(
+            source,
+            session,
+            resolvePhase,
+            returnTypeRef,
+            name,
+            symbol,
+            initializer,
+            annotations,
+            typeParameters,
+            status,
+            containerSource,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildEnumEntry(init: FirEnumEntryBuilder.() -> Unit): FirEnumEntry {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirEnumEntryBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt

@@ -0,0 +1,65 @@
+/*
+ * 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.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirErrorFunctionImpl
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
+import org.jetbrains.kotlin.fir.references.impl.FirEmptyControlFlowGraphReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirErrorFunctionSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirErrorFunctionBuilder : FirAnnotationContainerBuilder {
+    override var source: FirSourceElement? = null
+    lateinit var session: FirSession
+    var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
+    val valueParameters: MutableList<FirValueParameter> = mutableListOf()
+    lateinit var diagnostic: FirDiagnostic
+    lateinit var symbol: FirErrorFunctionSymbol
+
+    override fun build(): FirErrorFunction {
+        return FirErrorFunctionImpl(
+            source,
+            session,
+            resolvePhase,
+            annotations,
+            typeParameters,
+            valueParameters,
+            diagnostic,
+            symbol,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildErrorFunction(init: FirErrorFunctionBuilder.() -> Unit): FirErrorFunction {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirErrorFunctionBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFieldBuilder.kt

@@ -0,0 +1,71 @@
+/*
+ * 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.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
+import org.jetbrains.kotlin.fir.declarations.FirField
+import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirFieldImpl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+open class FirFieldBuilder : FirAnnotationContainerBuilder {
+    override var source: FirSourceElement? = null
+    open lateinit var session: FirSession
+    open var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    open lateinit var returnTypeRef: FirTypeRef
+    open lateinit var name: Name
+    open lateinit var symbol: FirVariableSymbol<FirField>
+    open var isVar: Boolean by kotlin.properties.Delegates.notNull<Boolean>()
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    open val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
+    open lateinit var status: FirDeclarationStatus
+    open var containerSource: DeserializedContainerSource? = null
+
+    override fun build(): FirField {
+        return FirFieldImpl(
+            source,
+            session,
+            resolvePhase,
+            returnTypeRef,
+            name,
+            symbol,
+            isVar,
+            annotations,
+            typeParameters,
+            status,
+            containerSource,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildField(init: FirFieldBuilder.() -> Unit): FirField {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirFieldBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFileBuilder.kt

@@ -0,0 +1,59 @@
+/*
+ * 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.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.declarations.FirImport
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.impl.FirFileImpl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.name.FqName
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirFileBuilder : FirAnnotationContainerBuilder {
+    override var source: FirSourceElement? = null
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    lateinit var session: FirSession
+    var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    val imports: MutableList<FirImport> = mutableListOf()
+    val declarations: MutableList<FirDeclaration> = mutableListOf()
+    lateinit var name: String
+    lateinit var packageFqName: FqName
+
+    override fun build(): FirFile {
+        return FirFileImpl(
+            source,
+            annotations,
+            session,
+            resolvePhase,
+            imports,
+            declarations,
+            name,
+            packageFqName,
+        )
+    }
+
+}
+
+@UseExperimental(ExperimentalContracts::class)
+inline fun buildFile(init: FirFileBuilder.() -> Unit): FirFile {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirFileBuilder().apply(init).build()
+}