[FIR] Introduce new FIR node for SAM conversion

#KT-62847

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt

@@ -186,6 +186,10 @@ class ExpressionCheckersDiagnosticComponent(
         checkers.allBasicExpressionCheckers.check(varargArgumentsExpression, data)
     }
 
+    override fun visitSamConversionExpression(samConversionExpression: FirSamConversionExpression, data: CheckerContext) {
+        checkers.allBasicExpressionCheckers.check(samConversionExpression, data)
+    }
+
     override fun visitWrappedExpression(wrappedExpression: FirWrappedExpression, data: CheckerContext) {
         checkers.allBasicExpressionCheckers.check(wrappedExpression, data)
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirSamConversionExpression.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+// This file was generated automatically. See compiler/fir/tree/tree-generator/Readme.md.
+// DO NOT MODIFY IT MANUALLY.
+
+package org.jetbrains.kotlin.fir.expressions
+
+import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+/**
+ * Generated from: [org.jetbrains.kotlin.fir.tree.generator.FirTreeBuilder.samConversionExpression]
+ */
+abstract class FirSamConversionExpression : FirExpression() {
+    abstract override val source: KtSourceElement?
+    @UnresolvedExpressionTypeAccess
+    abstract override val coneTypeOrNull: ConeKotlinType?
+    abstract override val annotations: List<FirAnnotation>
+    abstract val expression: FirExpression
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitSamConversionExpression(this, data)
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
+        transformer.transformSamConversionExpression(this, data) as E
+
+    abstract override fun replaceConeTypeOrNull(newConeTypeOrNull: ConeKotlinType?)
+
+    abstract override fun replaceAnnotations(newAnnotations: List<FirAnnotation>)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSamConversionExpression
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirSamConversionExpressionBuilder.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+// This file was generated automatically. See compiler/fir/tree/tree-generator/Readme.md.
+// DO NOT MODIFY IT MANUALLY.
+
+@file:Suppress("DuplicatedCode", "unused")
+
+package org.jetbrains.kotlin.fir.expressions.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirSamConversionExpression
+import org.jetbrains.kotlin.fir.expressions.UnresolvedExpressionTypeAccess
+import org.jetbrains.kotlin.fir.expressions.impl.FirSamConversionExpressionImpl
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+
+@FirBuilderDsl
+class FirSamConversionExpressionBuilder : FirAnnotationContainerBuilder, FirExpressionBuilder {
+    override var source: KtSourceElement? = null
+    override var coneTypeOrNull: ConeKotlinType? = null
+    override val annotations: MutableList<FirAnnotation> = mutableListOf()
+    lateinit var expression: FirExpression
+
+    override fun build(): FirSamConversionExpression {
+        return FirSamConversionExpressionImpl(
+            source,
+            coneTypeOrNull,
+            annotations.toMutableOrEmpty(),
+            expression,
+        )
+    }
+
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun buildSamConversionExpression(init: FirSamConversionExpressionBuilder.() -> Unit): FirSamConversionExpression {
+    contract {
+        callsInPlace(init, InvocationKind.EXACTLY_ONCE)
+    }
+    return FirSamConversionExpressionBuilder().apply(init).build()
+}
+
+@OptIn(ExperimentalContracts::class, UnresolvedExpressionTypeAccess::class)
+inline fun buildSamConversionExpressionCopy(original: FirSamConversionExpression, init: FirSamConversionExpressionBuilder.() -> Unit): FirSamConversionExpression {
+    contract {
+        callsInPlace(init, InvocationKind.EXACTLY_ONCE)
+    }
+    val copyBuilder = FirSamConversionExpressionBuilder()
+    copyBuilder.source = original.source
+    copyBuilder.coneTypeOrNull = original.coneTypeOrNull
+    copyBuilder.annotations.addAll(original.annotations)
+    copyBuilder.expression = original.expression
+    return copyBuilder.apply(init).build()
+}

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+// This file was generated automatically. See compiler/fir/tree/tree-generator/Readme.md.
+// DO NOT MODIFY IT MANUALLY.
+
+@file:Suppress("DuplicatedCode", "unused")
+
+package org.jetbrains.kotlin.fir.expressions.impl
+
+import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.fir.MutableOrEmptyList
+import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirSamConversionExpression
+import org.jetbrains.kotlin.fir.expressions.UnresolvedExpressionTypeAccess
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+import org.jetbrains.kotlin.fir.visitors.transformInplace
+
+@OptIn(UnresolvedExpressionTypeAccess::class)
+internal class FirSamConversionExpressionImpl(
+    override val source: KtSourceElement?,
+    @property:UnresolvedExpressionTypeAccess
+    override var coneTypeOrNull: ConeKotlinType?,
+    override var annotations: MutableOrEmptyList<FirAnnotation>,
+    override var expression: FirExpression,
+) : FirSamConversionExpression() {
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        annotations.forEach { it.accept(visitor, data) }
+        expression.accept(visitor, data)
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirSamConversionExpressionImpl {
+        transformAnnotations(transformer, data)
+        expression = expression.transform(transformer, data)
+        return this
+    }
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSamConversionExpressionImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
+    override fun replaceConeTypeOrNull(newConeTypeOrNull: ConeKotlinType?) {
+        coneTypeOrNull = newConeTypeOrNull
+    }
+
+    override fun replaceAnnotations(newAnnotations: List<FirAnnotation>) {
+        annotations = newAnnotations.toMutableOrEmpty()
+    }
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt

@@ -185,6 +185,9 @@ abstract class FirDefaultVisitor<out R, in D> : FirVisitor<R, D>() {
     override fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): R =
         visitExpression(varargArgumentsExpression, data)
 
+    override fun visitSamConversionExpression(samConversionExpression: FirSamConversionExpression, data: D): R =
+        visitExpression(samConversionExpression, data)
+
     override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): R =
         visitExpression(resolvedQualifier, data)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt

@@ -130,6 +130,8 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() {
 
     override fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression) = visitExpression(varargArgumentsExpression)
 
+    override fun visitSamConversionExpression(samConversionExpression: FirSamConversionExpression) = visitExpression(samConversionExpression)
+
     override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) = visitExpression(resolvedQualifier)
 
     override fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference) = visitExpression(resolvedReifiedParameterReference)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt

@@ -971,6 +971,14 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
         return transformVarargArgumentsExpression(varargArgumentsExpression, data)
     }
 
+    open fun transformSamConversionExpression(samConversionExpression: FirSamConversionExpression, data: D): FirStatement {
+        return transformElement(samConversionExpression, data)
+    }
+
+    final override fun visitSamConversionExpression(samConversionExpression: FirSamConversionExpression, data: D): FirStatement {
+        return transformSamConversionExpression(samConversionExpression, data)
+    }
+
     open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): FirStatement {
         return transformElement(resolvedQualifier, data)
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt

@@ -377,6 +377,9 @@ abstract class FirVisitor<out R, in D> {
     open fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): R =
         visitElement(varargArgumentsExpression, data)
 
+    open fun visitSamConversionExpression(samConversionExpression: FirSamConversionExpression, data: D): R =
+        visitElement(samConversionExpression, data)
+
     open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): R =
         visitElement(resolvedQualifier, data)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt

@@ -971,6 +971,14 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(varargArgumentsExpression)
     }
 
+    final override fun visitSamConversionExpression(samConversionExpression: FirSamConversionExpression, data: Nothing?) {
+        visitSamConversionExpression(samConversionExpression)
+    }
+
+    open fun visitSamConversionExpression(samConversionExpression: FirSamConversionExpression) {
+        visitElement(samConversionExpression)
+    }
+
     final override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: Nothing?) {
         visitResolvedQualifier(resolvedQualifier)
     }

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

@@ -750,6 +750,12 @@ class FirRenderer(
             print(")")
         }
 
+        override fun visitSamConversionExpression(samConversionExpression: FirSamConversionExpression) {
+            print("SAM(")
+            samConversionExpression.expression.accept(this)
+            print(")")
+        }
+
         override fun visitCall(call: FirCall) {
             callArgumentsRenderer?.renderArguments(call.arguments)
         }

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

@@ -416,6 +416,10 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
 
         noBuilder(constExpression)
 
+        builder(samConversionExpression) {
+            withCopy()
+        }
+
         // -----------------------------------------------------------------------
 
         findImplementationsWithElementInParents(annotationContainer).forEach {

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

@@ -149,6 +149,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val spreadArgumentExpression by element(Expression, wrappedArgumentExpression)
     val namedArgumentExpression by element(Expression, wrappedArgumentExpression)
     val varargArgumentsExpression by element(Expression, expression)
+    val samConversionExpression by element(Expression, expression)
 
     val resolvedQualifier by element(Expression, expression)
     val errorResolvedQualifier by element(Expression, resolvedQualifier, diagnosticHolder)

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

@@ -615,6 +615,10 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
             +field("varargElementType", typeRef)
         }
 
+        samConversionExpression.configure {
+            +field("expression", expression)
+        }
+
         resolvedQualifier.configure {
             +field("packageFqName", fqNameType)
             +field("relativeClassFqName", fqNameType, nullable = true)