[FIR] Implement builders for leaf nodes of FIR tree

2020-01-31 14:00:12 +03:00
parent b0c1387279
commit d57fa859c8
319 changed files with 11298 additions and 4284 deletions
@@ -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()
                }
            }
        }
@@ -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()
@@ -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")
+    }
 }

@@ -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()
+}
@@ -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()
+}
+
@@ -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()
+}
@@ -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()
+}
@@ -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()
+}
@@ -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
            }
    }
@@ -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
    }
 }
@@ -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
        }
@@ -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) {