IrOperatorExpression -> IrPrimitiveCall

All "primitives" have their descriptors now.

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BranchingExpressionGenerator.kt

@@ -158,13 +158,13 @@ class BranchingExpressionGenerator(val statementGenerator: StatementGenerator) :
         return when (inOperator) {
             IrOperator.IN -> irInCall
             IrOperator.NOT_IN ->
-                IrUnaryOperatorImpl(ktCondition.startOffset, ktCondition.endOffset, IrOperator.EXCL, context.irBuiltIns.booleanNot, irInCall)
+                IrUnaryPrimitiveImpl(ktCondition.startOffset, ktCondition.endOffset, IrOperator.EXCL, context.irBuiltIns.booleanNot, irInCall)
             else -> throw AssertionError("Expected 'in' or '!in', got $inOperator")
         }
     }
 
-    private fun generateEqualsCondition(irSubject: IrVariable, ktCondition: KtWhenConditionWithExpression): IrBinaryOperatorImpl =
-            IrBinaryOperatorImpl(
+    private fun generateEqualsCondition(irSubject: IrVariable, ktCondition: KtWhenConditionWithExpression): IrBinaryPrimitiveImpl =
+            IrBinaryPrimitiveImpl(
                     ktCondition.startOffset, ktCondition.endOffset,
                     IrOperator.EQEQ, context.irBuiltIns.eqeq,
                     irSubject.defaultLoad(), statementGenerator.generateExpression(ktCondition.expression!!)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt

@@ -150,8 +150,8 @@ class OperatorExpressionGenerator(
             IrOperator.IN ->
                 irContainsCall
             IrOperator.NOT_IN ->
-                IrUnaryOperatorImpl(expression.startOffset, expression.endOffset, IrOperator.EXCL, context.irBuiltIns.booleanNot,
-                                    irContainsCall)
+                IrUnaryPrimitiveImpl(expression.startOffset, expression.endOffset, IrOperator.EXCL, context.irBuiltIns.booleanNot,
+                                     irContainsCall)
             else ->
                 throw AssertionError("Unexpected in-operator $irOperator")
         }
@@ -163,15 +163,15 @@ class OperatorExpressionGenerator(
         val irArgument1 = statementGenerator.generateExpression(expression.right!!)
 
 
-        val irIdentityEquals = IrBinaryOperatorImpl(expression.startOffset, expression.endOffset, irOperator, context.irBuiltIns.eqeqeq,
-                                                    irArgument0, irArgument1)
+        val irIdentityEquals = IrBinaryPrimitiveImpl(expression.startOffset, expression.endOffset, irOperator, context.irBuiltIns.eqeqeq,
+                                                     irArgument0, irArgument1)
 
         return when (irOperator) {
             IrOperator.EQEQEQ ->
                 irIdentityEquals
             IrOperator.EXCLEQEQ ->
-                IrUnaryOperatorImpl(expression.startOffset, expression.endOffset, IrOperator.EXCL, context.irBuiltIns.booleanNot,
-                                    irIdentityEquals)
+                IrUnaryPrimitiveImpl(expression.startOffset, expression.endOffset, IrOperator.EXCL, context.irBuiltIns.booleanNot,
+                                     irIdentityEquals)
             else ->
                 throw AssertionError("Unexpected identity operator $irOperator")
         }
@@ -182,15 +182,15 @@ class OperatorExpressionGenerator(
         val irArgument0 = statementGenerator.generateExpression(expression.left!!)
         val irArgument1 = statementGenerator.generateExpression(expression.right!!)
 
-        val irEquals = IrBinaryOperatorImpl(expression.startOffset, expression.endOffset,
-                                            irOperator, context.irBuiltIns.eqeq, irArgument0, irArgument1)
+        val irEquals = IrBinaryPrimitiveImpl(expression.startOffset, expression.endOffset,
+                                             irOperator, context.irBuiltIns.eqeq, irArgument0, irArgument1)
 
         return when (irOperator) {
             IrOperator.EQEQ ->
                 irEquals
             IrOperator.EXCLEQ ->
-                IrUnaryOperatorImpl(expression.startOffset, expression.endOffset, IrOperator.EXCLEQ,
-                                    context.irBuiltIns.booleanNot, irEquals)
+                IrUnaryPrimitiveImpl(expression.startOffset, expression.endOffset, IrOperator.EXCLEQ,
+                                     context.irBuiltIns.booleanNot, irEquals)
             else ->
                 throw AssertionError("Unexpected equality operator $irOperator")
         }
@@ -210,7 +210,7 @@ class OperatorExpressionGenerator(
             else -> throw AssertionError("Unexpected comparison operator: $irOperator")
         }
 
-        return IrUnaryOperatorImpl(expression.startOffset, expression.endOffset, irOperator, compareToZeroDescriptor, irCompareToCall)
+        return IrUnaryPrimitiveImpl(expression.startOffset, expression.endOffset, irOperator, compareToZeroDescriptor, irCompareToCall)
     }
 
 

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/Primitives.kt

@@ -21,11 +21,11 @@ import org.jetbrains.kotlin.ir.expressions.*
 
 fun primitiveOp1(startOffset: Int, endOffset: Int, primitiveOpDescriptor: CallableDescriptor, irOperator: IrOperator,
                  argument: IrExpression): IrExpression =
-        IrUnaryOperatorImpl(startOffset, endOffset, irOperator, primitiveOpDescriptor, argument)
+        IrUnaryPrimitiveImpl(startOffset, endOffset, irOperator, primitiveOpDescriptor, argument)
 
 fun primitiveOp2(startOffset: Int, endOffset: Int, primitiveOpDescriptor: CallableDescriptor, irOperator: IrOperator,
                  argument1: IrExpression, argument2: IrExpression): IrExpression =
-        IrBinaryOperatorImpl(startOffset, endOffset, irOperator, primitiveOpDescriptor, argument1, argument2)
+        IrBinaryPrimitiveImpl(startOffset, endOffset, irOperator, primitiveOpDescriptor, argument1, argument2)
 
 fun Generator.constNull(startOffset: Int, endOffset: Int): IrExpression =
         IrConstImpl.constNull(startOffset, endOffset, context.builtIns.nullableNothingType)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrPrimitiveCall.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.ir.*
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.types.KotlinType
 
-abstract class IrOperatorCallBase(
+abstract class IrPrimitiveCallBase(
         startOffset: Int,
         endOffset: Int,
         override val operator: IrOperator,
@@ -52,12 +52,12 @@ abstract class IrOperatorCallBase(
     }
 }
 
-class IrNullaryOperatorImpl constructor(
+class IrNullaryPrimitiveImpl constructor(
         startOffset: Int,
         endOffset: Int,
         operator: IrOperator,
         descriptor: CallableDescriptor
-) : IrOperatorCallBase(startOffset, endOffset, operator, descriptor) {
+) : IrPrimitiveCallBase(startOffset, endOffset, operator, descriptor) {
     override fun getChild(slot: Int): IrElement? = null
 
     override fun replaceChild(slot: Int, newChild: IrElement) {
@@ -69,12 +69,12 @@ class IrNullaryOperatorImpl constructor(
     }
 }
 
-class IrUnaryOperatorImpl private constructor(
+class IrUnaryPrimitiveImpl private constructor(
         startOffset: Int,
         endOffset: Int,
         operator: IrOperator,
         descriptor: CallableDescriptor
-) : IrOperatorCallBase(startOffset, endOffset, operator, descriptor) {
+) : IrPrimitiveCallBase(startOffset, endOffset, operator, descriptor) {
     constructor(
             startOffset: Int,
             endOffset: Int,
@@ -113,12 +113,12 @@ class IrUnaryOperatorImpl private constructor(
     }
 }
 
-class IrBinaryOperatorImpl(
+class IrBinaryPrimitiveImpl(
         startOffset: Int,
         endOffset: Int,
         operator: IrOperator,
         descriptor: CallableDescriptor
-) : IrOperatorCallBase(startOffset, endOffset, operator, descriptor) {
+) : IrPrimitiveCallBase(startOffset, endOffset, operator, descriptor) {
     constructor(
             startOffset: Int,
             endOffset: Int,