[FIR] Replace FIR tree with generated implementation

2019-09-26 15:36:32 +03:00
parent d6d4b3329b
commit cb981919f9
366 changed files with 11081 additions and 8224 deletions
@@ -10,20 +10,25 @@ import com.intellij.psi.tree.IElementType
 import com.intellij.psi.tree.TokenSet
 import org.jetbrains.kotlin.KtNodeType
 import org.jetbrains.kotlin.KtNodeTypes.*
+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.FirTypeParameterContainer
+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.impl.FirDeclarationStatusImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirPropertyImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirVariableImpl
-import org.jetbrains.kotlin.fir.declarations.impl.addDefaultBoundIfNecessary
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.FirVariable
 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.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
@@ -72,7 +77,7 @@ fun LighterASTNode.isExpression(): Boolean {
    }
 }

-fun FirTypeParameterContainer.joinTypeParameters(typeConstraints: List<TypeConstraint>) {
+fun FirTypeParametersOwner.joinTypeParameters(typeConstraints: List<TypeConstraint>) {
    typeConstraints.forEach { typeConstraint ->
        this.typeParameters.forEach { typeParameter ->
            if (typeConstraint.identifier == typeParameter.name.identifier) {
@@ -125,11 +130,18 @@ fun generateDestructuringBlock(
        }
        val isVar = multiDeclaration.isVar
        for ((index, entry) in multiDeclaration.entries.withIndex()) {
-            statements += FirVariableImpl(
-                session, null, entry.name,
-                entry.returnTypeRef, isVar,
-                FirComponentCallImpl(null, index + 1, generateResolvedAccessExpression(null, container)),
-                FirVariableSymbol(entry.name) // TODO?
+            statements += FirPropertyImpl(
+                null,
+                session,
+                entry.returnTypeRef,
+                null,
+                entry.name,
+                FirComponentCallImpl(null, generateResolvedAccessExpression(null, container), index + 1),
+                null,
+                isVar,
+                FirPropertySymbol(CallableId(entry.name)), // TODO?
+                true,
+                FirDeclarationStatusImpl(Visibilities.LOCAL,  Modality.FINAL)
            ).apply {
                annotations += entry.annotations
                symbol.bind(this)
@@ -10,10 +10,12 @@ import com.intellij.psi.TokenType
 import com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.KtNodeTypes.*
 import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.NAME_FOR_DEFAULT_VALUE_PARAMETER
 import org.jetbrains.kotlin.fir.builder.Context
 import org.jetbrains.kotlin.fir.builder.generateAccessorsByDelegate
 import org.jetbrains.kotlin.fir.builder.generateComponentFunctions
@@ -28,6 +30,7 @@ import org.jetbrains.kotlin.fir.lightTree.fir.modifier.Modifier
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.TypeModifier
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.TypeParameterModifier
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.TypeProjectionModifier
+import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.FirDelegatedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
@@ -76,8 +79,8 @@ class DeclarationsConverter(
        }

        val firFile = FirFileImpl(
-            session,
            null,
+            session,
            fileName,
            context.packageFqName
        )
@@ -358,20 +361,25 @@ class DeclarationsConverter(
        val isLocal = isClassLocal(classNode) { getParent() }

        return withChildClassName(className) {
-            val firClass = FirClassImpl(
-                session,
-                null,
-                FirClassSymbol(context.currentClassId),
-                className,
+            val status = FirDeclarationStatusImpl(
                if (isLocal) Visibilities.LOCAL else modifiers.getVisibility(),
-                modifiers.getModality(),
-                modifiers.hasExpect(),
-                modifiers.hasActual(),
-                classKind,
-                isInner = modifiers.isInner(),
-                isCompanion = modifiers.isCompanion() && classKind == ClassKind.OBJECT,
-                isData = modifiers.isDataClass() && classKind != ClassKind.OBJECT,
+                modifiers.getModality()
+            ).apply {
+                isExpect = modifiers.hasExpect()
+                isActual = modifiers.hasActual()
+                isInner = modifiers.isInner()
+                isCompanion = modifiers.isCompanion() && classKind == ClassKind.OBJECT
+                isData = modifiers.isDataClass() && classKind != ClassKind.OBJECT
                isInline = modifiers.hasInline()
+            }
+            val firClass = FirClassImpl(
+                null,
+                session,
+                className,
+                status,
+                classKind,
+                FirClassSymbol(context.currentClassId)
+
            )
            firClass.annotations += modifiers.annotations
            firClass.typeParameters += firTypeParameters
@@ -446,7 +454,7 @@ class DeclarationsConverter(
        superTypeRefs.ifEmpty { superTypeRefs += implicitAnyType }
        val delegatedType = delegatedSuperTypeRef ?: implicitAnyType

-        return FirAnonymousObjectImpl(null).apply {
+        return FirAnonymousObjectImpl(null, session).apply {
            annotations += modifiers.annotations
            this.superTypeRefs += superTypeRefs
            this.typeRef = superTypeRefs.first()
@@ -493,10 +501,10 @@ class DeclarationsConverter(
        val enumEntryName = identifier.nameAsSafeName()
        return withChildClassName(enumEntryName) {
            val firEnumEntry = FirEnumEntryImpl(
-                session,
                null,
-                FirClassSymbol(context.currentClassId),
-                enumEntryName
+                session,
+                enumEntryName,
+                FirClassSymbol(context.currentClassId)
            )
            firEnumEntry.annotations += modifiers.annotations

@@ -581,21 +589,28 @@ class DeclarationsConverter(
            isThis = false
        ).extractArgumentsFrom(classWrapper.superTypeCallEntry, stubMode)

+        val status = FirDeclarationStatusImpl(
+            if (primaryConstructor != null) modifiers.getVisibility() else defaultVisibility,
+            Modality.FINAL
+        ).apply {
+            isExpect = modifiers.hasExpect()
+            isActual = modifiers.hasActual()
+            isInner = classWrapper.isInner()
+        }
+
        return PrimaryConstructor(
            FirPrimaryConstructorImpl(
-                session,
                null,
-                FirConstructorSymbol(callableIdForClassConstructor()),
-                if (primaryConstructor != null) modifiers.getVisibility() else defaultVisibility,
-                modifiers.hasExpect(),
-                modifiers.hasActual(),
-                classWrapper.isInner(),
+                session,
                classWrapper.delegatedSelfTypeRef,
-                firDelegatedCall
+                null,
+                status,
+                FirConstructorSymbol(callableIdForClassConstructor())
            ).apply {
                annotations += modifiers.annotations
                this.typeParameters += typeParametersFromSelfType(classWrapper.delegatedSelfTypeRef)
                this.valueParameters += valueParameters.map { it.firValueParameter }
+                this.delegatedConstructor = firDelegatedCall
            }, valueParameters
        )
    }
@@ -613,8 +628,8 @@ class DeclarationsConverter(
        }

        return FirAnonymousInitializerImpl(
-            session,
            null,
+            session,
            if (stubMode) FirEmptyExpressionBlock() else firBlock
        )
    }
@@ -641,17 +656,22 @@ class DeclarationsConverter(
            if (classWrapper.isObjectLiteral()) FirErrorTypeRefImpl(null, "Constructor in object")
            else classWrapper.delegatedSelfTypeRef

+        val status = FirDeclarationStatusImpl(modifiers.getVisibility(), Modality.FINAL).apply {
+            isExpect = modifiers.hasExpect()
+            isActual = modifiers.hasActual()
+            isInner = classWrapper.isInner()
+        }
+
        val firConstructor = FirConstructorImpl(
-            session,
            null,
-            FirConstructorSymbol(callableIdForClassConstructor()),
-            modifiers.getVisibility(),
-            modifiers.hasExpect(),
-            modifiers.hasActual(),
-            classWrapper.isInner(),
+            session,
            delegatedSelfTypeRef,
-            constructorDelegationCall
-        )
+            null,
+            status,
+            FirConstructorSymbol(callableIdForClassConstructor())
+        ).apply {
+            delegatedConstructor = constructorDelegationCall
+        }

        context.firFunctions += firConstructor
        firConstructor.annotations += modifiers.annotations
@@ -716,15 +736,17 @@ class DeclarationsConverter(
        }

        val typeAliasName = identifier.nameAsSafeName()
+        val status = FirDeclarationStatusImpl(modifiers.getVisibility(), Modality.FINAL).apply {
+            isExpect = modifiers.hasExpect()
+            isActual = modifiers.hasActual()
+        }
        return withChildClassName(typeAliasName) {
            return@withChildClassName FirTypeAliasImpl(
-                session,
                null,
-                FirTypeAliasSymbol(context.currentClassId),
+                session,
                typeAliasName,
-                modifiers.getVisibility(),
-                modifiers.hasExpect(),
-                modifiers.hasActual(),
+                status,
+                FirTypeAliasSymbol(context.currentClassId),
                firType
            ).apply {
                annotations += modifiers.annotations
@@ -772,51 +794,57 @@ class DeclarationsConverter(
        val parentNode = property.getParent()
        val isLocal = !(parentNode?.tokenType == KT_FILE || parentNode?.tokenType == CLASS_BODY)
        return if (isLocal) {
-            FirVariableImpl(
+            FirPropertyImpl(
+                null,
                session,
+                returnType,
                null,
                propertyName,
-                returnType,
-                isVar,
                firExpression,
-                delegate = delegateExpression?.let {
+                delegateExpression?.let {
                    FirWrappedDelegateExpressionImpl(
                        null, expressionConverter.getAsFirExpression(it, "Incorrect delegate expression")
                    )
-                }
+                },
+                isVar,
+                FirPropertySymbol(CallableId(propertyName)),
+                true,
+                FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
            ).apply {
                annotations += modifiers.annotations
                this.generateAccessorsByDelegate(this@DeclarationsConverter.session, member = false, stubMode = stubMode)
            }
        } else {
-            FirMemberPropertyImpl(
-                session,
+            val status = FirDeclarationStatusImpl(modifiers.getVisibility(), modifiers.getModality()).apply {
+                isExpect = modifiers.hasExpect()
+                isActual = modifiers.hasActual()
+                isOverride = modifiers.hasOverride()
+                isConst = modifiers.isConst()
+                isLateInit = modifiers.hasLateinit()
+            }
+            FirPropertyImpl(
                null,
-                FirPropertySymbol(callableIdForName(propertyName)),
-                propertyName,
-                modifiers.getVisibility(),
-                modifiers.getModality(),
-                modifiers.hasExpect(),
-                modifiers.hasActual(),
-                modifiers.hasOverride(),
-                modifiers.isConst(),
-                modifiers.hasLateinit(),
-                receiverType,
+                session,
                returnType,
-                isVar,
+                receiverType,
+                propertyName,
                firExpression,
                delegateExpression?.let {
                    FirWrappedDelegateExpressionImpl(
                        null,
                        expressionConverter.getAsFirExpression(it, "Should have delegate")
                    )
-                }
+                },
+                isVar,
+                FirPropertySymbol(callableIdForName(propertyName)),
+                false,
+                status
            ).apply {
                this.typeParameters += firTypeParameters
                this.joinTypeParameters(typeConstraints)
                annotations += modifiers.annotations
-                this.getter = getter ?: FirDefaultPropertyGetter(session, null, returnType, modifiers.getVisibility())
-                this.setter = if (isVar) setter ?: FirDefaultPropertySetter(session, null, returnType, modifiers.getVisibility()) else null
+                this.getter = getter ?: FirDefaultPropertyGetter(null, session, returnType, modifiers.getVisibility())
+                this.setter = if (isVar) setter ?: FirDefaultPropertySetter(null, session, returnType, modifiers.getVisibility()) else null
                generateAccessorsByDelegate(
                    this@DeclarationsConverter.session, member = parentNode?.tokenType != KT_FILE, stubMode = stubMode
                )
@@ -858,8 +886,19 @@ class DeclarationsConverter(
            }
        }

-        return FirVariableImpl(
-            session, null, identifier.nameAsSafeName(), firType ?: implicitType, false, null
+        val name = identifier.nameAsSafeName()
+        return FirPropertyImpl(
+            null,
+            session,
+            firType ?: implicitType,
+            null,
+            name,
+            null,
+            null,
+            false,
+            FirPropertySymbol(CallableId(name)),
+            true,
+            FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
        ).apply {
            annotations += modifiers.annotations
        }
@@ -872,7 +911,12 @@ class DeclarationsConverter(
        var modifiers = Modifier()
        var isGetter = true
        var returnType: FirTypeRef? = null
-        var firValueParameters: FirValueParameter = FirDefaultSetterValueParameter(session, null, propertyTypeRef)
+        var firValueParameters: FirValueParameter = FirDefaultSetterValueParameter(
+            null,
+            session,
+            propertyTypeRef,
+            FirVariableSymbol(NAME_FOR_DEFAULT_VALUE_PARAMETER)
+        )
        var block: LighterASTNode? = null
        var expression: LighterASTNode? = null
        getterOrSetter.forEachChildren {
@@ -887,13 +931,15 @@ class DeclarationsConverter(
            }
        }

+        val status = FirDeclarationStatusImpl(modifiers.getVisibility(), Modality.FINAL)
+
        val firAccessor = FirPropertyAccessorImpl(
-            session,
            null,
-            isGetter,
-            modifiers.getVisibility(),
+            session,
            returnType ?: if (isGetter) propertyTypeRef else implicitUnitType,
-            FirPropertyAccessorSymbol()
+            FirPropertyAccessorSymbol(),
+            isGetter,
+            status
        )
        context.firFunctions += firAccessor
        firAccessor.annotations += modifiers.annotations
@@ -924,10 +970,11 @@ class DeclarationsConverter(
        }

        return FirValueParameterImpl(
-            session,
            null,
-            firValueParameter.name,
+            session,
            if (firValueParameter.returnTypeRef == implicitType) propertyTypeRef else firValueParameter.returnTypeRef,
+            firValueParameter.name,
+            FirVariableSymbol(firValueParameter.name),
            firValueParameter.defaultValue,
            isCrossinline = modifiers.hasCrossinline() || firValueParameter.isCrossinline,
            isNoinline = modifiers.hasNoinline() || firValueParameter.isNoinline,
@@ -976,34 +1023,38 @@ class DeclarationsConverter(
        val parentNode = functionDeclaration.getParent()
        val isLocal = !(parentNode?.tokenType == KT_FILE || parentNode?.tokenType == CLASS_BODY)
        val firFunction = if (identifier == null) {
-            FirAnonymousFunctionImpl(session, null, returnType!!, receiverType, FirAnonymousFunctionSymbol())
+            FirAnonymousFunctionImpl(null, session, returnType!!, receiverType, FirAnonymousFunctionSymbol())
        } else {
            val functionName = identifier.nameAsSafeName()
-            FirMemberFunctionImpl(
-                session,
-                null,
-                FirNamedFunctionSymbol(callableIdForName(functionName, isLocal)),
-                functionName,
+            val status = FirDeclarationStatusImpl(
                if (isLocal) Visibilities.LOCAL else modifiers.getVisibility(),
-                modifiers.getModality(),
-                modifiers.hasExpect(),
-                modifiers.hasActual(),
-                modifiers.hasOverride(),
-                modifiers.hasOperator(),
-                modifiers.hasInfix(),
-                modifiers.hasInline(),
-                modifiers.hasTailrec(),
-                modifiers.hasExternal(),
-                modifiers.hasSuspend(),
+                modifiers.getModality()
+            ).apply {
+                isExpect = modifiers.hasExpect()
+                isActual = modifiers.hasActual()
+                isOverride = modifiers.hasOverride()
+                isOperator = modifiers.hasOperator()
+                isInfix = modifiers.hasInfix()
+                isInline = modifiers.hasInline()
+                isTailRec = modifiers.hasTailrec()
+                isExternal = modifiers.hasExternal()
+                isSuspend = modifiers.hasSuspend()
+            }
+            FirSimpleFunctionImpl(
+                null,
+                session,
+                returnType!!,
                receiverType,
-                returnType!!
+                functionName,
+                status,
+                FirNamedFunctionSymbol(callableIdForName(functionName, isLocal))
            )
        }

        context.firFunctions += firFunction
        firFunction.annotations += modifiers.annotations

-        if (firFunction is FirMemberFunctionImpl) {
+        if (firFunction is FirSimpleFunctionImpl) {
            firFunction.typeParameters += firTypeParameters
            firFunction.joinTypeParameters(typeConstraints)
        }
@@ -1112,8 +1163,8 @@ class DeclarationsConverter(
        }

        return FirDelegatedTypeRefImpl(
-            firTypeRef,
-            firExpression
+            firExpression,
+            firTypeRef
        )
    }

@@ -1175,10 +1226,10 @@ class DeclarationsConverter(
        }

        val firTypeParameter = FirTypeParameterImpl(
-            session,
            null,
-            FirTypeParameterSymbol(),
+            session,
            identifier.nameAsSafeName(),
+            FirTypeParameterSymbol(),
            typeParameterModifiers.getVariance(),
            typeParameterModifiers.hasReified()
        )
@@ -1211,7 +1262,7 @@ class DeclarationsConverter(
            }
        }

-        return firType.also { (it as FirAbstractAnnotatedTypeRef).annotations += typeModifiers.annotations }
+        return firType.also { (it.annotations as MutableList<FirAnnotationCall>) += typeModifiers.annotations }
    }

    /**
@@ -1307,8 +1358,8 @@ class DeclarationsConverter(
        return if (isStarProjection) FirStarProjectionImpl(null)
        else FirTypeProjectionWithVarianceImpl(
            null,
-            modifiers.getVariance(),
-            firType
+            firType,
+            modifiers.getVariance()
        )
    }

@@ -1369,11 +1420,13 @@ class DeclarationsConverter(
            }
        }

+        val name = identifier.nameAsSafeName()
        val firValueParameter = FirValueParameterImpl(
-            session,
            null,
-            identifier.nameAsSafeName(),
+            session,
            firType ?: implicitType,
+            name,
+            FirVariableSymbol(name),
            firExpression,
            isCrossinline = modifiers.hasCrossinline(),
            isNoinline = modifiers.hasNoinline(),
@@ -9,25 +9,34 @@ import com.intellij.lang.LighterASTNode
 import com.intellij.psi.TokenType
 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.builder.*
+import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.declarations.impl.FirAnonymousFunctionImpl
+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.declarations.impl.FirVariableImpl
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.*
-import org.jetbrains.kotlin.fir.labels.FirLabelImpl
+import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.impl.FirLabelImpl
 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.FirErrorNamedReference
-import org.jetbrains.kotlin.fir.references.FirExplicitSuperReference
-import org.jetbrains.kotlin.fir.references.FirExplicitThisReference
-import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference
+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.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
@@ -116,16 +125,23 @@ class ExpressionsConverter(
            }
        }

-        return FirAnonymousFunctionImpl(session, null, implicitType, implicitType, FirAnonymousFunctionSymbol()).apply {
+        return FirAnonymousFunctionImpl(null, session, implicitType, implicitType, FirAnonymousFunctionSymbol()).apply {
            context.firFunctions += this
            var destructuringBlock: FirExpression? = null
            for (valueParameter in valueParameterList) {
                val multiDeclaration = valueParameter.destructuringDeclaration
                valueParameters += if (multiDeclaration != null) {
+                    val name = Name.special("<destruct>")
                    val multiParameter = FirValueParameterImpl(
-                        this@ExpressionsConverter.session, null, Name.special("<destruct>"),
+                        null,
+                        this@ExpressionsConverter.session,
                        FirImplicitTypeRefImpl(null),
-                        defaultValue = null, isCrossinline = false, isNoinline = false, isVararg = false
+                        name,
+                        FirVariableSymbol(name),
+                        defaultValue = null,
+                        isCrossinline = false,
+                        isNoinline = false,
+                        isVararg = false
                    )
                    destructuringBlock = generateDestructuringBlock(
                        this@ExpressionsConverter.session,
@@ -205,7 +221,7 @@ class ExpressionsConverter(
        return if (conventionCallName != null || operationToken == IDENTIFIER) {
            FirFunctionCallImpl(null).apply {
                calleeReference = FirSimpleNamedReference(
-                    null, conventionCallName ?: operationTokenName.nameAsSafeName()
+                    null, conventionCallName ?: operationTokenName.nameAsSafeName(), null
                )
                explicitReceiver = getAsFirExpression(leftArgNode, "No left operand")
                arguments += rightArgAsFir
@@ -303,7 +319,7 @@ class ExpressionsConverter(
                ) { getAsFirExpression(this) }
            }
            FirFunctionCallImpl(null).apply {
-                calleeReference = FirSimpleNamedReference(null, conventionCallName)
+                calleeReference = FirSimpleNamedReference(null, conventionCallName, null)
                explicitReceiver = getAsFirExpression(argument, "No operand")
            }
        } else {
@@ -401,10 +417,9 @@ class ExpressionsConverter(
            }
        }

-        //TODO use contracts?
-        if (firSelector is FirModifiableQualifiedAccess<*>) {
-            (firSelector as FirModifiableQualifiedAccess<*>).safe = isSafe
-            (firSelector as FirModifiableQualifiedAccess<*>).explicitReceiver = firReceiver
+        (firSelector as? FirModifiableQualifiedAccess)?.let {
+            it.safe = isSafe
+            it.explicitReceiver = firReceiver
        }
        return firSelector
    }
@@ -429,12 +444,12 @@ class ExpressionsConverter(

        return FirFunctionCallImpl(null).apply {
            this.calleeReference = when {
-                name != null -> FirSimpleNamedReference(null, name.nameAsSafeName())
+                name != null -> FirSimpleNamedReference(null, name.nameAsSafeName(), null)
                additionalArgument != null -> {
                    arguments += additionalArgument!!
-                    FirSimpleNamedReference(null, OperatorNameConventions.INVOKE)
+                    FirSimpleNamedReference(null, OperatorNameConventions.INVOKE, null)
                }
-                else -> FirErrorNamedReference(null, "Call has no callee")
+                else -> FirErrorNamedReferenceImpl(null, "Call has no callee")
            }

            context.firFunctionCalls += this
@@ -477,9 +492,18 @@ class ExpressionsConverter(
        whenExpression.forEachChildren {
            when (it.tokenType) {
                PROPERTY -> subjectVariable = (declarationsConverter.convertPropertyDeclaration(it) as FirVariable<*>).let { variable ->
-                    FirVariableImpl(
-                        session, null, variable.name, variable.returnTypeRef,
-                        isVar = false, initializer = variable.initializer
+                    FirPropertyImpl(
+                        null,
+                        session,
+                        variable.returnTypeRef,
+                        null,
+                        variable.name,
+                        variable.initializer,
+                        null,
+                        false,
+                        FirPropertySymbol(CallableId(variable.name)),
+                        true,
+                        FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
                    )
                }
                DESTRUCTURING_DECLARATION -> subjectExpression =
@@ -568,7 +592,7 @@ class ExpressionsConverter(

        val name = if (isNegate) OperatorNameConventions.NOT else SpecialNames.NO_NAME_PROVIDED
        return FirFunctionCallImpl(null).apply {
-            calleeReference = FirSimpleNamedReference(null, name)
+            calleeReference = FirSimpleNamedReference(null, name, null)
            explicitReceiver = firExpression
        }
    }
@@ -601,7 +625,7 @@ class ExpressionsConverter(
            }
        }
        return FirFunctionCallImpl(null).apply {
-            calleeReference = FirSimpleNamedReference(null, OperatorNameConventions.GET)
+            calleeReference = FirSimpleNamedReference(null, OperatorNameConventions.GET, null)
            explicitReceiver = firExpression
            arguments += indices
        }
@@ -640,7 +664,7 @@ class ExpressionsConverter(
    private fun convertSimpleNameExpression(referenceExpression: LighterASTNode): FirQualifiedAccessExpression {
        return FirQualifiedAccessExpressionImpl(null).apply {
            calleeReference =
-                FirSimpleNamedReference(null, referenceExpression.asText.nameAsSafeName())
+                FirSimpleNamedReference(null, referenceExpression.asText.nameAsSafeName(), null)
        }
    }

@@ -701,7 +725,7 @@ class ExpressionsConverter(
            val iteratorVal = generateTemporaryVariable(
                this@ExpressionsConverter.session, null, Name.special("<iterator>"),
                FirFunctionCallImpl(null).apply {
-                    calleeReference = FirSimpleNamedReference(null, Name.identifier("iterator"))
+                    calleeReference = FirSimpleNamedReference(null, Name.identifier("iterator"), null)
                    explicitReceiver = generateResolvedAccessExpression(null, rangeVal)
                }
            )
@@ -709,7 +733,7 @@ class ExpressionsConverter(
            statements += FirWhileLoopImpl(
                null,
                FirFunctionCallImpl(null).apply {
-                    calleeReference = FirSimpleNamedReference(null, Name.identifier("hasNext"))
+                    calleeReference = FirSimpleNamedReference(null, Name.identifier("hasNext"), null)
                    explicitReceiver = generateResolvedAccessExpression(null, iteratorVal)
                }
            ).configure {
@@ -723,7 +747,7 @@ class ExpressionsConverter(
                        this@ExpressionsConverter.session, null,
                        if (multiDeclaration != null) Name.special("<destruct>") else parameter!!.firValueParameter.name,
                        FirFunctionCallImpl(null).apply {
-                            calleeReference = FirSimpleNamedReference(null, Name.identifier("next"))
+                            calleeReference = FirSimpleNamedReference(null, Name.identifier("next"), null)
                            explicitReceiver = generateResolvedAccessExpression(null, iteratorVal)
                        }
                    )
@@ -838,7 +862,7 @@ class ExpressionsConverter(
            }
        }

-        return FirWhenExpressionImpl(null).apply {
+        return FirWhenExpressionImpl(null, null, null).apply {
            val trueBranch = convertLoopBody(thenBlock)
            branches += FirWhenBranchImpl(null, firCondition, trueBranch)
            val elseBranch = convertLoopBody(elseBlock)
@@ -953,7 +977,12 @@ class ExpressionsConverter(
            }
        }
        return when {
-            identifier != null -> FirNamedArgumentExpressionImpl(null, identifier.nameAsSafeName(), isSpread, firExpression)
+            identifier != null -> FirNamedArgumentExpressionImpl(
+                null,
+                firExpression,
+                isSpread,
+                identifier.nameAsSafeName()
+            )
            isSpread -> FirSpreadArgumentExpressionImpl(null, firExpression)
            else -> firExpression
        }
@@ -7,8 +7,8 @@ package org.jetbrains.kotlin.fir.lightTree.fir

 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.builder.generateTemporaryVariable
+import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.FirVariable
 import org.jetbrains.kotlin.fir.lightTree.converter.generateDestructuringBlock

 data class DestructuringDeclaration(
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.lightTree.fir

-import org.jetbrains.kotlin.fir.declarations.impl.FirConstructorImpl
+import org.jetbrains.kotlin.fir.declarations.FirConstructor

 data class PrimaryConstructor(
-    val firConstructor: FirConstructorImpl,
+    val firConstructor: FirConstructor,
    val valueParameters: List<ValueParameter>
 )
@@ -8,17 +8,12 @@ package org.jetbrains.kotlin.fir.lightTree.fir
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
-import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
-import org.jetbrains.kotlin.fir.declarations.impl.FirMemberPropertyImpl
-import org.jetbrains.kotlin.fir.expressions.FirBlock
-import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.declarations.impl.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirQualifiedAccessExpressionImpl
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.Modifier
-import org.jetbrains.kotlin.fir.references.FirPropertyFromParameterCallableReference
+import org.jetbrains.kotlin.fir.references.impl.FirPropertyFromParameterCallableReference
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
-import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl

@@ -40,31 +35,34 @@ class ValueParameter(
            type = FirErrorTypeRefImpl(null, "Incomplete code")
        }

-        return FirMemberPropertyImpl(
-            session,
+        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,
-            FirPropertySymbol(callableId),
            name,
-            modifiers.getVisibility(),
-            modifiers.getModality(),
-            modifiers.hasExpect(),
-            modifiers.hasActual(),
-            isOverride = modifiers.hasOverride(),
-            isConst = false,
-            isLateInit = false,
-            receiverTypeRef = null,
-            returnTypeRef = type,
-            isVar = this.isVar,
-            initializer = FirQualifiedAccessExpressionImpl(null).apply {
+            FirQualifiedAccessExpressionImpl(null).apply {
                calleeReference = FirPropertyFromParameterCallableReference(
                    null, name, this@ValueParameter.firValueParameter.symbol
                )
            },
-            delegate = null
+            null,
+            this.isVar,
+            FirPropertySymbol(callableId),
+            false,
+            status
        ).apply {
            annotations += this@ValueParameter.firValueParameter.annotations
-            getter = FirDefaultPropertyGetter(session, null, type, modifiers.getVisibility())
-            setter = if (this.isVar) FirDefaultPropertySetter(session, null, type, modifiers.getVisibility()) else null
+            getter = FirDefaultPropertyGetter(null, session, type, modifiers.getVisibility())
+            setter = if (this.isVar) FirDefaultPropertySetter(null, session, type, modifiers.getVisibility()) else null
        }
    }
 }
@@ -10,7 +10,8 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.expressions.impl.FirAbstractAnnotatedElement
+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
@@ -21,7 +22,7 @@ import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PROPERTY_MOD
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VISIBILITY_MODIFIER

 class Modifier(
-    psi: PsiElement? = null,
+    override val psi: PsiElement? = null,
    private val classModifiers: MutableList<ClassModifier> = mutableListOf(),
    private val memberModifiers: MutableList<MemberModifier> = mutableListOf(),
    private val visibilityModifiers: MutableList<VisibilityModifier> = mutableListOf(),
@@ -30,7 +31,9 @@ class Modifier(
    private val inheritanceModifiers: MutableList<InheritanceModifier> = mutableListOf(),
    private val parameterModifiers: MutableList<ParameterModifier> = mutableListOf(),
    private val platformModifiers: MutableList<PlatformModifier> = mutableListOf()
-) : FirAbstractAnnotatedElement(psi) {
+) : FirAbstractAnnotatedElement {
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+
    fun addModifier(modifier: LighterASTNode) {
        val tokenType = modifier.tokenType
        when {
@@ -7,13 +7,16 @@ package org.jetbrains.kotlin.fir.lightTree.fir.modifier

 import com.intellij.lang.LighterASTNode
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.expressions.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.lexer.KtTokens

 class TypeModifier(
-    psi: PsiElement? = null,
+    override val psi: PsiElement? = null,
    var hasSuspend: Boolean = false
-) : FirAbstractAnnotatedElement(psi) {
+) : FirAbstractAnnotatedElement {
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+
    fun addModifier(modifier: LighterASTNode) {
        when (modifier.tokenType) {
            KtTokens.SUSPEND_KEYWORD -> this.hasSuspend = true
@@ -7,17 +7,19 @@ package org.jetbrains.kotlin.fir.lightTree.fir.modifier

 import com.intellij.lang.LighterASTNode
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.expressions.impl.FirAbstractAnnotatedElement
+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.types.Variance

 class TypeParameterModifier(
-    psi: PsiElement? = null,
+    override val psi: PsiElement? = null,
    private val varianceModifiers: MutableList<VarianceModifier> = mutableListOf(),
-
    private var reificationModifier: ReificationModifier? = null
-) : FirAbstractAnnotatedElement(psi) {
+) : FirAbstractAnnotatedElement {
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+
    fun addModifier(modifier: LighterASTNode) {
        val tokenType = modifier.tokenType
        when {
@@ -7,14 +7,17 @@ package org.jetbrains.kotlin.fir.lightTree.fir.modifier

 import com.intellij.lang.LighterASTNode
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.expressions.impl.FirAbstractAnnotatedElement
+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.types.Variance

 class TypeProjectionModifier(
-    psi: PsiElement? = null,
+    override val psi: PsiElement? = null,
    private val varianceModifiers: MutableList<VarianceModifier> = mutableListOf()
-) : FirAbstractAnnotatedElement(psi) {
+) : FirAbstractAnnotatedElement {
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+
    fun addModifier(modifier: LighterASTNode) {
        val tokenType = modifier.tokenType
        when {