Introduce typeRef for FirExpression

This helps both body resolve & conversion to IR

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

@@ -100,13 +100,13 @@ open class FirBodyResolveTransformer(val session: FirSession, val implicitTypeOn
                 )
             }
             FirOperation.AS -> {
-                bindingContext[resolved] = resolved.typeRef
+                bindingContext[resolved] = resolved.conversionTypeRef
             }
             FirOperation.SAFE_AS -> {
                 bindingContext[resolved] =
-                    resolved.typeRef.withReplacedConeType(
+                    resolved.conversionTypeRef.withReplacedConeType(
                         session,
-                        resolved.typeRef.coneTypeUnsafe().withNullability(ConeNullability.NULLABLE)
+                        resolved.conversionTypeRef.coneTypeUnsafe().withNullability(ConeNullability.NULLABLE)
                     )
             }
             else -> error("Unknown type operator")

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -618,7 +618,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         print(" ")
         print(typeOperatorCall.operation.operator)
         print(" ")
-        typeOperatorCall.typeRef.accept(this)
+        typeOperatorCall.conversionTypeRef.accept(this)
         print(")")
     }
 
@@ -853,7 +853,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         print(operatorCall.operation.operator)
         if (operatorCall is FirTypeOperatorCall) {
             print("/")
-            operatorCall.typeRef.accept(this)
+            operatorCall.conversionTypeRef.accept(this)
         }
         visitCall(operatorCall)
     }
@@ -882,7 +882,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         classReferenceExpression.annotations.renderAnnotations()
         print("<getClass>")
         print("(")
-        classReferenceExpression.typeRef.accept(this)
+        classReferenceExpression.classTypeRef.accept(this)
         print(")")
     }
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt

@@ -25,6 +25,7 @@ interface FirAnonymousFunction : @VisitedSupertype FirFunction, FirExpression, F
             parameter.accept(visitor, data)
         }
         body?.accept(visitor, data)
-        // Don't call super<FirExpression>.acceptChildren (annotations are already processed)
+        typeRef.accept(visitor, data)
+        // Don't call super<FirExpression>.acceptChildren (annotations & typeRef are already processed)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt

@@ -19,6 +19,7 @@ interface FirEnumEntry : @VisitedSupertype FirRegularClass, FirCall {
         for (argument in arguments) {
             argument.accept(visitor, data)
         }
+        typeRef.accept(visitor, data)
         super<FirRegularClass>.acceptChildren(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirAnonymousFunctionImpl(
@@ -20,9 +21,16 @@ class FirAnonymousFunctionImpl(
     override var returnTypeRef: FirTypeRef,
     override var receiverTypeRef: FirTypeRef?
 ) : FirAbstractFunction(session, psi), FirAnonymousFunction, FirModifiableFunction {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
     override var label: FirLabel? = null
 
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
         returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
         label = label?.transformSingle(transformer, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt

@@ -11,7 +11,9 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
@@ -19,15 +21,22 @@ class FirAnonymousObjectImpl(
     session: FirSession,
     psi: PsiElement?
 ) : FirAbstractAnnotatedDeclaration(session, psi), FirAnonymousObject, FirModifiableClass {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
     override val superTypeRefs = mutableListOf<FirTypeRef>()
 
     override val declarations = mutableListOf<FirDeclaration>()
 
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
         return super<FirAnonymousObject>.accept(visitor, data)
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
         superTypeRefs.transformInplace(transformer, data)
         declarations.transformInplace(transformer, data)
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt

@@ -11,8 +11,14 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
 class FirEnumEntryImpl(
@@ -35,5 +41,18 @@ class FirEnumEntryImpl(
     isData = false,
     isInline = false
 ), FirEnumEntry {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
     override val arguments = mutableListOf<FirExpression>()
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirRegularClass {
+        typeRef = typeRef.transformSingle(transformer, data)
+        arguments.transformInplace(transformer, data)
+
+        return super<FirClassImpl>.transformChildren(transformer, data)
+    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorLoop.kt

@@ -17,7 +17,7 @@ class FirErrorLoop(
     session: FirSession,
     psi: PsiElement?,
     override val reason: String
-) : FirAbstractElement(session, psi), FirErrorExpression, FirLoop {
+) : FirAbstractElement(session, psi), FirErrorStatement, FirLoop {
     override val annotations: List<FirAnnotationCall> = listOf()
 
     override val condition: FirExpression = FirErrorExpressionImpl(session, psi, reason)
@@ -25,7 +25,7 @@ class FirErrorLoop(
     override val block: FirBlock = FirEmptyExpressionBlock(session)
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
-        return super<FirErrorExpression>.accept(visitor, data)
+        return super<FirErrorStatement>.accept(visitor, data)
     }
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArraySetCall.kt

@@ -22,6 +22,7 @@ interface FirArraySetCall : @VisitedSupertype FirCall, FirAssignment {
             index.accept(visitor, data)
         }
         acceptAnnotations(visitor, data)
+        typeRef.accept(visitor, data)
         super<FirAssignment>.acceptChildren(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBlock.kt

@@ -17,6 +17,7 @@ interface FirBlock : FirExpression {
         for (statement in statements) {
             statement.accept(visitor, data)
         }
+        typeRef.accept(visitor, data)
         super.acceptChildren(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirClassReferenceExpression.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirClassReferenceExpression : FirExpression {
-    val typeRef: FirTypeRef
+    val classTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitClassReferenceExpression(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirErrorStatement.kt

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.expressions
+
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirErrorStatement : FirStatement {
+    val reason: String
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitErrorStatement(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpression.kt

@@ -7,11 +7,21 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirResolvedCallableReference
 import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirExpression : FirStatement {
+    val typeRef: FirTypeRef
+
+    fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitExpression(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        super.acceptChildren(visitor, data)
+        typeRef.accept(visitor, data)
+    }
 }
 
 fun FirExpression.toResolvedCallableReference(): FirResolvedCallableReference? {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirFunctionCall.kt

@@ -23,6 +23,7 @@ interface FirFunctionCall : @VisitedSupertype FirCall, FirQualifiedAccess, FirTy
         for (typeArgument in typeArguments) {
             typeArgument.accept(visitor, data)
         }
+        typeRef.accept(visitor, data)
         super<FirQualifiedAccess>.acceptChildren(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirQualifiedAccessExpression.kt

@@ -14,5 +14,6 @@ interface FirQualifiedAccessExpression : @VisitedSupertype FirQualifiedAccess, F
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         super<FirQualifiedAccess>.acceptChildren(visitor, data)
+        typeRef.accept(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTypeOperatorCall.kt

@@ -12,13 +12,13 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 interface FirTypeOperatorCall : FirOperatorCall {
     val argument: FirExpression get() = arguments.first()
 
-    val typeRef: FirTypeRef
+    val conversionTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitTypeOperatorCall(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        typeRef.accept(visitor, data)
+        conversionTypeRef.accept(visitor, data)
         super.acceptChildren(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractBlock.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.expressions.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+abstract class FirAbstractBlock(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractAnnotatedElement(session, psi), FirBlock {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+
+        return super<FirAbstractAnnotatedElement>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractExpression.kt

@@ -6,10 +6,28 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 abstract class FirAbstractExpression(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractStatement(session, psi), FirExpression
+) : FirAbstractStatement(session, psi), FirExpression {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+
+        return super<FirAbstractStatement>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArraySetCallImpl.kt

@@ -13,6 +13,9 @@ import org.jetbrains.kotlin.fir.expressions.FirArraySetCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirOperation
 import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
@@ -22,12 +25,19 @@ class FirArraySetCallImpl(
     value: FirExpression,
     operation: FirOperation
 ) : FirAbstractAssignment(session, psi, value, operation, false), FirArraySetCall {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
     override val indexes = mutableListOf<FirExpression>()
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         super<FirArraySetCall>.accept(visitor, data)
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
         indexes.transformInplace(transformer, data)
 
         return super<FirAbstractAssignment>.transformChildren(transformer, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockImpl.kt

@@ -16,11 +16,11 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 class FirBlockImpl(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractAnnotatedElement(session, psi), FirBlock {
+) : FirAbstractBlock(session, psi), FirBlock {
     override val statements = mutableListOf<FirStatement>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         statements.transformInplace(transformer, data)
-        return super<FirAbstractAnnotatedElement>.transformChildren(transformer, data)
+        return super<FirAbstractBlock>.transformChildren(transformer, data)
     }
 }

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

@@ -6,10 +6,27 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirCallableReferenceAccessImpl(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractQualifiedAccess(session, psi), FirCallableReferenceAccess
+) : FirAbstractQualifiedAccess(session, psi), FirCallableReferenceAccess {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+
+        return super<FirAbstractQualifiedAccess>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirClassReferenceExpressionImpl.kt

@@ -16,10 +16,10 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 class FirClassReferenceExpressionImpl(
     session: FirSession,
     psi: PsiElement?,
-    override var typeRef: FirTypeRef
+    override var classTypeRef: FirTypeRef
 ) : FirAbstractExpression(session, psi), FirClassReferenceExpression {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        typeRef = typeRef.transformSingle(transformer, data)
+        classTypeRef = classTypeRef.transformSingle(transformer, data)
         return super<FirAbstractExpression>.transformChildren(transformer, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirEmptyExpressionBlock.kt

@@ -10,6 +10,6 @@ import org.jetbrains.kotlin.fir.expressions.FirBlock
 
 class FirEmptyExpressionBlock(
     session: FirSession
-) : FirAbstractAnnotatedElement(session, null), FirBlock {
+) : FirAbstractBlock(session, null), FirBlock {
     override val statements = listOf()
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirQualifiedAccessExpressionImpl.kt

@@ -6,11 +6,28 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirQualifiedAccessExpressionImpl(
     session: FirSession,
     psi: PsiElement?,
     safe: Boolean = false
-) : FirAbstractQualifiedAccess(session, psi, safe), FirQualifiedAccessExpression
+) : FirAbstractQualifiedAccess(session, psi, safe), FirQualifiedAccessExpression {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+
+        return super<FirAbstractQualifiedAccess>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirSingleExpressionBlock.kt

@@ -15,12 +15,12 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 class FirSingleExpressionBlock(
     session: FirSession,
     private var statement: FirStatement
-) : FirAbstractAnnotatedElement(session, statement.psi), FirBlock {
+) : FirAbstractBlock(session, statement.psi), FirBlock {
     override val statements
         get() = listOf(statement)
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         statement = statement.transformSingle(transformer, data)
-        return super<FirAbstractAnnotatedElement>.transformChildren(transformer, data)
+        return super<FirAbstractBlock>.transformChildren(transformer, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirTypeOperatorCallImpl.kt

@@ -18,10 +18,10 @@ class FirTypeOperatorCallImpl(
     session: FirSession,
     psi: PsiElement?,
     override val operation: FirOperation,
-    override var typeRef: FirTypeRef
+    override var conversionTypeRef: FirTypeRef
 ) : FirAbstractCall(session, psi), FirTypeOperatorCall {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        typeRef = typeRef.transformSingle(transformer, data)
+        conversionTypeRef = conversionTypeRef.transformSingle(transformer, data)
         return super<FirAbstractCall>.transformChildren(transformer, data)
     }
 }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt

@@ -180,6 +180,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformClass(modifiableClass, data)
     }
 
+    open fun transformErrorStatement(errorStatement: FirErrorStatement, data: D): CompositeTransformResult<FirStatement> {
+        return transformStatement(errorStatement, data)
+    }
+
     open fun transformExpression(expression: FirExpression, data: D): CompositeTransformResult<FirStatement> {
         return transformStatement(expression, data)
     }
@@ -504,6 +508,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformErrorExpression(errorExpression, data)
     }
 
+    final override fun visitErrorStatement(errorStatement: FirErrorStatement, data: D): CompositeTransformResult<FirElement> {
+        return transformErrorStatement(errorStatement, data)
+    }
+
     final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirElement> {
         return transformErrorTypeRef(errorTypeRef, data)
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt

@@ -180,6 +180,10 @@ abstract class FirVisitor<out R, in D> {
         return visitClass(modifiableClass, data)
     }
 
+    open fun visitErrorStatement(errorStatement: FirErrorStatement, data: D): R {
+        return visitStatement(errorStatement, data)
+    }
+
     open fun visitExpression(expression: FirExpression, data: D): R {
         return visitStatement(expression, data)
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt

@@ -180,6 +180,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitClass(modifiableClass, null)
     }
 
+    open fun visitErrorStatement(errorStatement: FirErrorStatement) {
+        visitStatement(errorStatement, null)
+    }
+
     open fun visitExpression(expression: FirExpression) {
         visitStatement(expression, null)
     }
@@ -504,6 +508,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitErrorExpression(errorExpression)
     }
 
+    final override fun visitErrorStatement(errorStatement: FirErrorStatement, data: Nothing?) {
+        visitErrorStatement(errorStatement)
+    }
+
     final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?) {
         visitErrorTypeRef(errorTypeRef)
     }