JVM: rename IrIntrinsicFunction -> IntrinsicFunction

To avoid confusion that this might be an IR tree element.

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt

@@ -28,9 +28,9 @@ object ArrayIterator : IntrinsicMethod() {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
         val owner = classCodegen.typeMapper.mapClass(expression.symbol.owner.parentAsClass)
-        return IrIntrinsicFunction.create(expression, signature, classCodegen, listOf(owner)) {
+        return IntrinsicFunction.create(expression, signature, classCodegen, listOf(owner)) {
             val methodSignature = "(${owner.descriptor})${signature.returnType.descriptor}"
             val intrinsicOwner =
                 if (AsmUtil.isPrimitive(owner.elementType))

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySize.kt

@@ -23,8 +23,8 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 object ArraySize : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
-        return IrIntrinsicFunction.create(expression, signature, classCodegen) {
+        return IntrinsicFunction.create(expression, signature, classCodegen) {
             it.arraylength()
         }
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt

@@ -35,7 +35,7 @@ class BinaryOp(private val opcode: Int) : IntrinsicMethod() {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
         val returnType = signature.returnType
         val intermediateResultType = numberFunctionOperandType(returnType)
         val argTypes = if (!expression.symbol.owner.parentAsClass.defaultType.isChar()) {
@@ -44,7 +44,7 @@ class BinaryOp(private val opcode: Int) : IntrinsicMethod() {
             listOf(Type.CHAR_TYPE, signature.valueParameters[0].asmType)
         }
 
-        return IrIntrinsicFunction.create(expression, signature, classCodegen, argTypes) {
+        return IntrinsicFunction.create(expression, signature, classCodegen, argTypes) {
             it.visitInsn(returnType.getOpcode(opcode))
             StackValue.coerce(intermediateResultType, returnType, it)
         }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Clone.kt

@@ -32,14 +32,14 @@ object Clone : IntrinsicMethod() {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
         val isSuperCall = expression is IrCall && expression.superQualifierSymbol != null
         val opcode = if (isSuperCall) Opcodes.INVOKESPECIAL else Opcodes.INVOKEVIRTUAL
         val newSignature = signature.newReturnType(AsmTypes.OBJECT_TYPE)
         val argTypes0 = expression.argTypes(classCodegen)
         // Don't upcast receiver to java.lang.Cloneable, since 'clone' is protected in java.lang.Object.
         val argTypes = if (isSuperCall || argTypes0[0] == CLONEABLE_TYPE) listOf(AsmTypes.OBJECT_TYPE) else argTypes0
-        return IrIntrinsicFunction.create(expression, newSignature, classCodegen, argTypes) { mv ->
+        return IntrinsicFunction.create(expression, newSignature, classCodegen, argTypes) { mv ->
             mv.visitMethodInsn(opcode, "java/lang/Object", "clone", "()Ljava/lang/Object;", false)
         }
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt

@@ -54,14 +54,14 @@ object CompareTo : IntrinsicMethod() {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
         val callee = expression.symbol.owner
         val calleeParameter = callee.dispatchReceiverParameter ?: callee.extensionReceiverParameter!!
         val parameterType = comparisonOperandType(
             classCodegen.typeMapper.mapType(calleeParameter.type),
             signature.valueParameters.single().asmType,
         )
-        return IrIntrinsicFunction.create(expression, signature, classCodegen, listOf(parameterType, parameterType)) {
+        return IntrinsicFunction.create(expression, signature, classCodegen, listOf(parameterType, parameterType)) {
             genInvoke(parameterType, it)
         }
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt

@@ -160,11 +160,11 @@ class Ieee754Equals(val operandType: Type) : IntrinsicMethod() {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
         class Ieee754AreEqual(
             val left: Type,
             val right: Type
-        ) : IrIntrinsicFunction(expression, signature, classCodegen, listOf(left, right)) {
+        ) : IntrinsicFunction(expression, signature, classCodegen, listOf(left, right)) {
             override fun genInvokeInstruction(v: InstructionAdapter) {
                 v.invokestatic(
                     IntrinsicMethods.INTRINSICS_CLASS_NAME, "areEqual",
@@ -197,7 +197,7 @@ class Ieee754Equals(val operandType: Type) : IntrinsicMethod() {
                 Ieee754AreEqual(AsmTypes.OBJECT_TYPE, AsmTypes.OBJECT_TYPE)
 
             !arg0isNullable && !arg1isNullable ->
-                object : IrIntrinsicFunction(expression, signature, classCodegen, listOf(operandType, operandType)) {
+                object : IntrinsicFunction(expression, signature, classCodegen, listOf(operandType, operandType)) {
                     override fun genInvokeInstruction(v: InstructionAdapter) {
                         StackValue.cmp(KtTokens.EQEQ, operandType, StackValue.onStack(operandType), StackValue.onStack(operandType))
                             .put(Type.BOOLEAN_TYPE, v)

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Increment.kt

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 class Increment(private val myDelta: Int) : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
-        return IrIntrinsicFunction.create(expression, signature, classCodegen) {
+        return IntrinsicFunction.create(expression, signature, classCodegen) {
             genIncrement(signature.returnType, myDelta, it)
         }
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicFunction.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 
-abstract class IrIntrinsicFunction(
+abstract class IntrinsicFunction(
     val expression: IrFunctionAccessExpression,
     val signature: JvmMethodSignature,
     val classCodegen: ClassCodegen,
@@ -79,9 +79,9 @@ abstract class IrIntrinsicFunction(
             signature: JvmMethodSignature,
             classCodegen: ClassCodegen,
             argsTypes: List<Type> = expression.argTypes(classCodegen),
-            invokeInstruction: IrIntrinsicFunction.(InstructionAdapter) -> Unit,
+            invokeInstruction: IntrinsicFunction.(InstructionAdapter) -> Unit,
-        ): IrIntrinsicFunction =
+        ): IntrinsicFunction =
-            object : IrIntrinsicFunction(expression, signature, classCodegen, argsTypes) {
+            object : IntrinsicFunction(expression, signature, classCodegen, argsTypes) {
                 override fun genInvokeInstruction(v: InstructionAdapter) = invokeInstruction(v)
             }
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt

@@ -17,7 +17,7 @@ abstract class IntrinsicMethod : IntrinsicMarker {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
-    ): IrIntrinsicFunction = TODO("implement toCallable() or invoke() of $this")
+    ): IntrinsicFunction = TODO("implement toCallable() or invoke() of $this")
 
     open fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? =
         with(codegen) {

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicShouldHaveBeenLowered.kt

@@ -15,7 +15,7 @@ object IntrinsicShouldHaveBeenLowered : IntrinsicMethod() {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
         error("Intrinsic should have been lowered: '${expression.symbol.owner.render()}'")
     }
 }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Inv.kt

@@ -25,10 +25,10 @@ import org.jetbrains.org.objectweb.asm.Type
 object Inv : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
         val returnType = signature.returnType
         val type = numberFunctionOperandType(returnType)
-        return IrIntrinsicFunction.create(expression, signature, classCodegen, listOf(type)) {
+        return IntrinsicFunction.create(expression, signature, classCodegen, listOf(type)) {
             if (returnType == Type.LONG_TYPE) {
                 it.lconst(-1)
             } else {

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIllegalArgumentException.kt

@@ -33,8 +33,8 @@ object IrIllegalArgumentException : IntrinsicMethod() {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
-        return object : IrIntrinsicFunction(expression, signature, classCodegen, listOf(JAVA_STRING_TYPE)) {
+        return object : IntrinsicFunction(expression, signature, classCodegen, listOf(JAVA_STRING_TYPE)) {
             override fun genInvokeInstruction(v: InstructionAdapter) {
                 v.invokespecial(
                     exceptionTypeDescriptor.internalName,

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrNoWhenBranchMatchedException.kt

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 object IrNoWhenBranchMatchedException : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
-        return IrIntrinsicFunction.create(expression, signature, classCodegen) {
+        return IntrinsicFunction.create(expression, signature, classCodegen) {
             genThrow(it, "kotlin/NoWhenBranchMatchedException", null)
         }
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt

@@ -15,7 +15,7 @@ object IsArrayOf : IntrinsicMethod() {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
-    ): IrIntrinsicFunction = IrIntrinsicFunction.create(expression, signature, classCodegen) { v ->
+    ): IntrinsicFunction = IntrinsicFunction.create(expression, signature, classCodegen) { v ->
         val arrayType = classCodegen.context.irBuiltIns.arrayClass.typeWith(expression.getTypeArgument(0)!!)
         v.instanceOf(classCodegen.typeMapper.mapType(arrayType))
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IteratorNext.kt

@@ -29,12 +29,12 @@ import org.jetbrains.org.objectweb.asm.Type
 object IteratorNext : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
         // If the array element type is unboxed primitive, do not unbox. Otherwise AsmUtil.unbox throws exception
         val type = if (AsmUtil.isBoxedPrimitiveType(signature.returnType)) AsmUtil.unboxType(signature.returnType) else signature.returnType
         val newSignature = signature.newReturnType(type)
         val primitiveClassName = getKotlinPrimitiveClassName(type)
-        return IrIntrinsicFunction.create(expression, newSignature, classCodegen, listOf(getPrimitiveIteratorType(primitiveClassName))) {
+        return IntrinsicFunction.create(expression, newSignature, classCodegen, listOf(getPrimitiveIteratorType(primitiveClassName))) {
             it.invokevirtual(
                 getPrimitiveIteratorType(primitiveClassName).internalName,
                 "next${primitiveClassName.asString()}",

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/MonitorInstruction.kt

@@ -33,8 +33,8 @@ class MonitorInstruction private constructor(private val opcode: Int) : Intrinsi
 
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
-        return IrIntrinsicFunction.create(expression, signature, classCodegen, listOf(OBJECT_TYPE)) {
+        return IntrinsicFunction.create(expression, signature, classCodegen, listOf(OBJECT_TYPE)) {
             it.visitInsn(opcode)
         }
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NumberCast.kt

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 object NumberCast : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
-        return IrIntrinsicFunction.create(expression, signature, classCodegen) {
+        return IntrinsicFunction.create(expression, signature, classCodegen) {
             StackValue.coerce(argsTypes[0], signature.returnType, it)
         }
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt

@@ -17,9 +17,9 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 object RangeTo : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
         val argType = mapRangeTypeToPrimitiveType(signature.returnType)
-        return object : IrIntrinsicFunction(
+        return object : IntrinsicFunction(
             expression, signature, classCodegen, listOf(argType) + signature.valueParameters.map { argType }
         ) {
             override fun genInvokeInstruction(v: InstructionAdapter) {

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt

@@ -14,8 +14,8 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 object RangeUntil : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
-        return object : IrIntrinsicFunction(expression, signature, classCodegen, expression.argTypes(classCodegen)) {
+        return object : IntrinsicFunction(expression, signature, classCodegen, expression.argTypes(classCodegen)) {
             override fun genInvokeInstruction(v: InstructionAdapter) {
                 v.invokestatic(
                     "kotlin/ranges/RangesKt", "until",

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringGetChar.kt

@@ -23,8 +23,8 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 object StringGetChar : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
-        return IrIntrinsicFunction.create(expression, signature, classCodegen) {
+        return IntrinsicFunction.create(expression, signature, classCodegen) {
             it.invokevirtual("java/lang/String", "charAt", "(I)C", false)
         }
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringPlus.kt

@@ -18,8 +18,8 @@ object StringPlus : IntrinsicMethod() {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
-    ): IrIntrinsicFunction =
+    ): IntrinsicFunction =
-        IrIntrinsicFunction.create(expression, signature, classCodegen, listOf(AsmTypes.JAVA_STRING_TYPE, AsmTypes.OBJECT_TYPE)) {
+        IntrinsicFunction.create(expression, signature, classCodegen, listOf(AsmTypes.JAVA_STRING_TYPE, AsmTypes.OBJECT_TYPE)) {
             it.invokestatic(
                 IntrinsicMethods.INTRINSICS_CLASS_NAME,
                 "stringPlus",

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt

@@ -15,8 +15,8 @@ object ThrowKotlinNothingValueException : IntrinsicMethod() {
         expression: IrFunctionAccessExpression,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
-    ): IrIntrinsicFunction =
+    ): IntrinsicFunction =
-        IrIntrinsicFunction.create(expression, signature, classCodegen) { mv ->
+        IntrinsicFunction.create(expression, signature, classCodegen) { mv ->
             if (classCodegen.context.state.useKotlinNothingValueException) {
                 mv.anew(Type.getObjectType("kotlin/KotlinNothingValueException"))
                 mv.dup()

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryMinus.kt

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 object UnaryMinus : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
-        return IrIntrinsicFunction.create(expression, signature, classCodegen) {
+        return IntrinsicFunction.create(expression, signature, classCodegen) {
             it.neg(numberFunctionOperandType(signature.returnType))
         }
     }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryPlus.kt

@@ -23,8 +23,8 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 object UnaryPlus : IntrinsicMethod() {
     override fun toCallable(
         expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
-    ): IrIntrinsicFunction {
+    ): IntrinsicFunction {
-        return IrIntrinsicFunction.create(expression, signature, classCodegen) {
+        return IntrinsicFunction.create(expression, signature, classCodegen) {
             // Do nothing.
         }
     }