Raw FIR: introduce string concatenation call

This removes some 'plus' calls to be resolved

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -80,6 +80,8 @@ internal class Fir2IrVisitor(
 
     private val booleanType = FirImplicitBooleanTypeRef(session, null).toIrType(session, declarationStorage)
 
+    private val stringType = FirImplicitStringTypeRef(session, null).toIrType(session, declarationStorage)
+
     private fun ModuleDescriptor.findPackageFragmentForFile(file: FirFile): PackageFragmentDescriptor =
         getPackage(file.packageFqName).fragments.first()
 
@@ -1070,6 +1072,15 @@ internal class Fir2IrVisitor(
         }
     }
 
+    override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: Any?): IrElement {
+        return stringConcatenationCall.convertWithOffsets { startOffset, endOffset ->
+            IrStringConcatenationImpl(
+                startOffset, endOffset, stringType,
+                stringConcatenationCall.arguments.map { it.toIrExpression() }
+            )
+        }
+    }
+
     override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: Any?): IrElement {
         return typeOperatorCall.convertWithOffsets { startOffset, endOffset ->
             val irTypeOperand = typeOperatorCall.conversionTypeRef.toIrType(session, declarationStorage)

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt

@@ -304,14 +304,13 @@ internal fun Array<KtStringTemplateEntry>.toInterpolatingCall(
         }
         result = when {
             result == null -> nextArgument
-            callCreated && result is FirFunctionCallImpl -> result.apply {
+            callCreated && result is FirStringConcatenationCallImpl -> result.apply {
                 arguments += nextArgument
             }
             else -> {
                 callCreated = true
-                FirFunctionCallImpl(session, base).apply {
-                    calleeReference = FirSimpleNamedReference(session, base, OperatorNameConventions.PLUS)
-                    explicitReceiver = result
+                FirStringConcatenationCallImpl(session, base).apply {
+                    arguments += result!!
                     arguments += nextArgument
                 }
             }

compiler/fir/psi2fir/testData/rawBuilder/expressions/for.txt

@@ -43,7 +43,7 @@ FILE: for.kt
             lval <destruct>: <implicit> = <iterator>#.next#()
             lval x: <implicit> = <destruct>#.component1()
             lval y: <implicit> = <destruct>#.component2()
-            println#(String(x = ).plus#(x#, String( y = ), y#))
+            println#(<strcat>(String(x = ), x#, String( y = ), y#))
         }
 
     }

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

@@ -641,6 +641,11 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         print(")")
     }
 
+    override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) {
+        print("<strcat>")
+        visitCall(stringConcatenationCall)
+    }
+
     override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) {
         print("(")
         typeOperatorCall.argument.accept(this)

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

@@ -0,0 +1,13 @@
+/*
+ * 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 FirStringConcatenationCall : FirCall {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitStringConcatenationCall(this, data)
+}

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

@@ -0,0 +1,19 @@
+/*
+ * 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.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirStringConcatenationCall
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitStringTypeRef
+
+class FirStringConcatenationCallImpl(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractCall(session, psi), FirStringConcatenationCall {
+    override var typeRef: FirTypeRef = FirImplicitStringTypeRef(session, psi)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitBuiltinTypeRef.kt

@@ -63,3 +63,8 @@ class FirImplicitNothingTypeRef(
     psi: PsiElement?
 ) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.Nothing)
 
+class FirImplicitStringTypeRef(
+    session: FirSession,
+    psi: PsiElement?
+) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.String)
+

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

@@ -232,6 +232,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformOperatorCall(typeOperatorCall, data)
     }
 
+    open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): CompositeTransformResult<FirStatement> {
+        return transformCall(stringConcatenationCall, data)
+    }
+
     open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult<FirStatement> {
         return transformExpression(classReferenceExpression, data)
     }
@@ -668,6 +672,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformStatement(statement, data)
     }
 
+    final override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): CompositeTransformResult<FirElement> {
+        return transformStringConcatenationCall(stringConcatenationCall, data)
+    }
+
     final override fun visitSuperReference(superReference: FirSuperReference, data: D): CompositeTransformResult<FirElement> {
         return transformSuperReference(superReference, data)
     }

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

@@ -232,6 +232,10 @@ abstract class FirVisitor<out R, in D> {
         return visitOperatorCall(typeOperatorCall, data)
     }
 
+    open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): R {
+        return visitCall(stringConcatenationCall, data)
+    }
+
     open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): R {
         return visitExpression(classReferenceExpression, data)
     }

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

@@ -232,6 +232,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitOperatorCall(typeOperatorCall, null)
     }
 
+    open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) {
+        visitCall(stringConcatenationCall, null)
+    }
+
     open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) {
         visitExpression(classReferenceExpression, null)
     }
@@ -668,6 +672,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitStatement(statement)
     }
 
+    final override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: Nothing?) {
+        visitStringConcatenationCall(stringConcatenationCall)
+    }
+
     final override fun visitSuperReference(superReference: FirSuperReference, data: Nothing?) {
         visitSuperReference(superReference)
     }