[FIR] Fix determination of which type is FIR type in tree generator

^KT-52832 Fixed

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirCallableReferenceAccessImpl.kt

@@ -38,6 +38,7 @@ internal class FirCallableReferenceAccessImpl(
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
+        contextReceiverArguments.forEach { it.accept(visitor, data) }
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
@@ -52,6 +53,7 @@ internal class FirCallableReferenceAccessImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirCallableReferenceAccessImpl {
         typeRef = typeRef.transform(transformer, data)
         transformAnnotations(transformer, data)
+        contextReceiverArguments.transformInplace(transformer, data)
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirComponentCallImpl.kt

@@ -47,6 +47,7 @@ internal class FirComponentCallImpl(
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
+        contextReceiverArguments.forEach { it.accept(visitor, data) }
         typeArguments.forEach { it.accept(visitor, data) }
         argumentList.accept(visitor, data)
         calleeReference.accept(visitor, data)
@@ -62,6 +63,7 @@ internal class FirComponentCallImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirComponentCallImpl {
         typeRef = typeRef.transform(transformer, data)
         transformAnnotations(transformer, data)
+        contextReceiverArguments.transformInplace(transformer, data)
         transformTypeArguments(transformer, data)
         argumentList = argumentList.transform(transformer, data)
         transformCalleeReference(transformer, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt

@@ -38,6 +38,7 @@ internal class FirDelegatedConstructorCallImpl(
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         annotations.forEach { it.accept(visitor, data) }
         argumentList.accept(visitor, data)
+        contextReceiverArguments.forEach { it.accept(visitor, data) }
         constructedTypeRef.accept(visitor, data)
         calleeReference.accept(visitor, data)
     }
@@ -45,6 +46,7 @@ internal class FirDelegatedConstructorCallImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCallImpl {
         transformAnnotations(transformer, data)
         argumentList = argumentList.transform(transformer, data)
+        contextReceiverArguments.transformInplace(transformer, data)
         constructedTypeRef = constructedTypeRef.transform(transformer, data)
         transformCalleeReference(transformer, data)
         return this

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirFunctionCallImpl.kt

@@ -41,6 +41,7 @@ open class FirFunctionCallImpl @FirImplementationDetail constructor(
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
+        contextReceiverArguments.forEach { it.accept(visitor, data) }
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
@@ -56,6 +57,7 @@ open class FirFunctionCallImpl @FirImplementationDetail constructor(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirFunctionCallImpl {
         typeRef = typeRef.transform(transformer, data)
         transformAnnotations(transformer, data)
+        contextReceiverArguments.transformInplace(transformer, data)
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirImplicitInvokeCallImpl.kt

@@ -43,6 +43,7 @@ internal class FirImplicitInvokeCallImpl(
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
+        contextReceiverArguments.forEach { it.accept(visitor, data) }
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
@@ -58,6 +59,7 @@ internal class FirImplicitInvokeCallImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirImplicitInvokeCallImpl {
         typeRef = typeRef.transform(transformer, data)
         transformAnnotations(transformer, data)
+        contextReceiverArguments.transformInplace(transformer, data)
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirIntegerLiteralOperatorCallImpl.kt

@@ -41,6 +41,7 @@ internal class FirIntegerLiteralOperatorCallImpl(
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
+        contextReceiverArguments.forEach { it.accept(visitor, data) }
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
@@ -56,6 +57,7 @@ internal class FirIntegerLiteralOperatorCallImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirIntegerLiteralOperatorCallImpl {
         typeRef = typeRef.transform(transformer, data)
         transformAnnotations(transformer, data)
+        contextReceiverArguments.transformInplace(transformer, data)
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirPropertyAccessExpressionImpl.kt

@@ -39,6 +39,7 @@ class FirPropertyAccessExpressionImpl @FirImplementationDetail constructor(
         typeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
         calleeReference.accept(visitor, data)
+        contextReceiverArguments.forEach { it.accept(visitor, data) }
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
@@ -53,6 +54,7 @@ class FirPropertyAccessExpressionImpl @FirImplementationDetail constructor(
         typeRef = typeRef.transform(transformer, data)
         transformAnnotations(transformer, data)
         transformCalleeReference(transformer, data)
+        contextReceiverArguments.transformInplace(transformer, data)
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirThisReceiverExpressionImpl.kt

@@ -40,6 +40,7 @@ internal class FirThisReceiverExpressionImpl(
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
+        contextReceiverArguments.forEach { it.accept(visitor, data) }
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
@@ -54,6 +55,7 @@ internal class FirThisReceiverExpressionImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirThisReceiverExpressionImpl {
         typeRef = typeRef.transform(transformer, data)
         transformAnnotations(transformer, data)
+        contextReceiverArguments.transformInplace(transformer, data)
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirVariableAssignmentImpl.kt

@@ -44,6 +44,7 @@ internal class FirVariableAssignmentImpl(
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         calleeReference.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
+        contextReceiverArguments.forEach { it.accept(visitor, data) }
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
@@ -59,6 +60,7 @@ internal class FirVariableAssignmentImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirVariableAssignmentImpl {
         transformCalleeReference(transformer, data)
         transformAnnotations(transformer, data)
+        contextReceiverArguments.transformInplace(transformer, data)
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt

@@ -351,7 +351,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
                 value = "whenRef.value.subject!!.typeRef"
                 withGetter = true
             }
-            useTypes(whenExpressionType)
+            useTypes(whenExpression)
         }
 
         impl(wrappedDelegateExpression) {
@@ -471,11 +471,11 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         impl(simpleFunction)
 
         impl(safeCallExpression) {
-            useTypes(safeCallCheckedSubjectType)
+            useTypes(checkedSafeCallSubject)
         }
 
         impl(checkedSafeCallSubject) {
-            useTypes(expressionType)
+            useTypes(expression)
         }
 
         impl(resolvedQualifier) {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -192,7 +192,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
         }
 
         contextReceiverArgumentListOwner.configure {
-            +fieldList("contextReceiverArguments", expressionType, withReplace = true)
+            +fieldList("contextReceiverArguments", expression, withReplace = true)
         }
 
         qualifiedAccess.configure {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt

@@ -46,30 +46,24 @@ val operationKindType = type("fir.expressions", "LogicOperationKind")
 val coneKotlinTypeType = type(ConeKotlinType::class)
 val coneSimpleKotlinTypeType = type(ConeSimpleKotlinType::class)
 
-val whenExpressionType = generatedType("expressions", "FirWhenExpression")
-val expressionType = generatedType("expressions", "FirExpression")
-val safeCallCheckedSubjectType = generatedType("expressions", "FirCheckedSafeCallSubject")
-
 val whenRefType = generatedType("", "FirExpressionRef<FirWhenExpression>")
 val safeCallOriginalReceiverReferenceType = generatedType("", "FirExpressionRef<FirExpression>")
 val safeCallCheckedSubjectReferenceType = generatedType("", "FirExpressionRef<FirCheckedSafeCallSubject>")
 
 val firModuleDataType = type("fir", "FirModuleData")
-val emptyCfgReferenceType = generatedType("references.impl", "FirEmptyControlFlowGraphReference")
+val noReceiverExpressionType = generatedType("expressions.impl", "FirNoReceiverExpression", firType = true)
-val noReceiverExpressionType = generatedType("expressions.impl", "FirNoReceiverExpression")
+val implicitTypeRefType = generatedType("types.impl", "FirImplicitTypeRefImpl", firType = true)
-val implicitTypeRefType = generatedType("types.impl", "FirImplicitTypeRefImpl")
 val firQualifierPartType = type("fir.types", "FirQualifierPart")
-val ConeErrorTypeType = type(ConeErrorType::class)
 val simpleNamedReferenceType = generatedType("references.impl", "FirSimpleNamedReference")
-val explicitThisReferenceType = generatedType("references.impl", "FirExplicitThisReference")
+val explicitThisReferenceType = generatedType("references.impl", "FirExplicitThisReference", firType = true)
-val explicitSuperReferenceType = generatedType("references.impl", "FirExplicitSuperReference")
+val explicitSuperReferenceType = generatedType("references.impl", "FirExplicitSuperReference", firType = true)
-val implicitBooleanTypeRefType = generatedType("types.impl", "FirImplicitBooleanTypeRef")
+val implicitBooleanTypeRefType = generatedType("types.impl", "FirImplicitBooleanTypeRef", firType = true)
-val implicitNothingTypeRefType = generatedType("types.impl", "FirImplicitNothingTypeRef")
+val implicitNothingTypeRefType = generatedType("types.impl", "FirImplicitNothingTypeRef", firType = true)
-val implicitStringTypeRefType = generatedType("types.impl", "FirImplicitStringTypeRef")
+val implicitStringTypeRefType = generatedType("types.impl", "FirImplicitStringTypeRef", firType = true)
-val implicitUnitTypeRefType = generatedType("types.impl", "FirImplicitUnitTypeRef")
+val implicitUnitTypeRefType = generatedType("types.impl", "FirImplicitUnitTypeRef", firType = true)
 val resolvePhaseType = type("fir.declarations", "FirResolvePhase")
 val propertyBodyResolveStateType = type("fir.declarations", "FirPropertyBodyResolveState")
-val stubReferenceType = generatedType("references.impl", "FirStubReference")
+val stubReferenceType = generatedType("references.impl", "FirStubReference", firType = true)
 
 val firBasedSymbolType = type("fir.symbols", "FirBasedSymbol")
 val backingFieldSymbolType = type("fir.symbols.impl", "FirBackingFieldSymbol")
@@ -104,5 +98,5 @@ val deprecationsPerUseSiteType = type("fir.declarations", "DeprecationsPerUseSit
 val emptyAnnotationArgumentMappingType = type("fir.expressions.impl", "FirEmptyAnnotationArgumentMapping")
 
 val firPropertySymbolType = type("fir.symbols.impl", "FirPropertySymbol")
-val errorTypeRefImplType = type("fir.types.impl", "FirErrorTypeRefImpl")
+val errorTypeRefImplType = type("fir.types.impl", "FirErrorTypeRefImpl", firType = true)
 

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/context/AbstractFirTreeBuilder.kt

@@ -93,16 +93,16 @@ abstract class AbstractFirTreeBuilder {
     }
 }
 
-fun generatedType(type: String): Type = generatedType("", type)
+fun generatedType(type: String, firType: Boolean = false): Type = generatedType("", type, firType)
 
-fun generatedType(packageName: String, type: String): Type {
+fun generatedType(packageName: String, type: String, firType: Boolean = false): Type {
     val realPackage = BASE_PACKAGE + if (packageName.isNotBlank()) ".$packageName" else ""
-    return type(realPackage, type, exactPackage = true)
+    return type(realPackage, type, exactPackage = true, firType)
 }
 
-fun type(packageName: String?, type: String, exactPackage: Boolean = false): Type {
+fun type(packageName: String?, type: String, exactPackage: Boolean = false, firType: Boolean = false): Type {
     val realPackage = if (exactPackage) packageName else packageName?.let { "org.jetbrains.kotlin.$it" }
-    return Type(realPackage, type)
+    return Type(realPackage, type, firType)
 }
 
 fun type(type: String): Type = type(null, type)

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Field.kt

@@ -219,5 +219,5 @@ class FieldList(
         )
     }
 
-    override val isFirType: Boolean = baseType is AbstractElement
+    override val isFirType: Boolean = baseType is AbstractElement || (baseType is Type && baseType.firType)
 }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Type.kt

@@ -5,6 +5,6 @@
 
 package org.jetbrains.kotlin.fir.tree.generator.model
 
-data class Type(override val packageName: String?, override val type: String) : Importable {
+data class Type(override val packageName: String?, override val type: String, val firType: Boolean = false) : Importable {
     val arguments = mutableListOf<String>()
-}
+}