IrTypes: update minor utilities

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt

@@ -197,10 +197,6 @@ fun IrBuilderWithScope.irAs(argument: IrExpression, type: IrType) =
 fun IrBuilderWithScope.irImplicitCast(argument: IrExpression, type: IrType) =
     IrTypeOperatorCallImpl(startOffset, endOffset, type, IrTypeOperator.IMPLICIT_CAST, type, type.classifierOrFail, argument)
 
-fun IrBuilderWithScope.irImplicitCast(argument: IrExpression, type: IrType, typeClassifier: IrClassifierSymbol) =
-    IrTypeOperatorCallImpl(startOffset, endOffset, type, IrTypeOperator.IMPLICIT_CAST, type, type.classifierOrFail, argument)
-
-
 fun IrBuilderWithScope.irInt(value: Int) =
     IrConstImpl.int(startOffset, endOffset, context.irBuiltIns.intType, value)
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/IrMemberFunctionBuilder.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.putDefault
 import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.types.IrType
 
 // This class can be used by kotlin-native.
 @Suppress("unused")
@@ -33,6 +34,7 @@ class IrMemberFunctionBuilder(
     context: IrGeneratorContext,
     val irClass: IrClass,
     val function: FunctionDescriptor,
+    val returnType: IrType,
     val origin: IrDeclarationOrigin,
     startOffset: Int = UNDEFINED_OFFSET,
     endOffset: Int = UNDEFINED_OFFSET
@@ -40,7 +42,7 @@ class IrMemberFunctionBuilder(
     lateinit var irFunction: IrFunction
 
     inline fun addToClass(body: IrMemberFunctionBuilder.(IrFunction) -> Unit): IrFunction {
-        irFunction = IrFunctionImpl(startOffset, endOffset, origin, function)
+        irFunction = IrFunctionImpl(startOffset, endOffset, origin, function, returnType)
         body(irFunction)
         irFunction.body = doBuild()
         irClass.declarations.add(irFunction)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/Primitives.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.ir.builders
 
+import org.jetbrains.kotlin.ir.expressions.IrElseBranch
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.expressions.IrWhen
@@ -30,7 +31,7 @@ fun primitiveOp1(
     origin: IrStatementOrigin,
     argument: IrExpression
 ): IrExpression =
-    IrUnaryPrimitiveImpl(startOffset, endOffset, origin, primitiveOpSymbol, argument)
+    IrUnaryPrimitiveImpl(startOffset, endOffset, primitiveOpSymbol.owner.returnType, origin, primitiveOpSymbol, argument)
 
 fun primitiveOp2(
     startOffset: Int, endOffset: Int,
@@ -38,10 +39,10 @@ fun primitiveOp2(
     origin: IrStatementOrigin,
     argument1: IrExpression, argument2: IrExpression
 ): IrExpression =
-    IrBinaryPrimitiveImpl(startOffset, endOffset, origin, primitiveOpSymbol, argument1, argument2)
+    IrBinaryPrimitiveImpl(startOffset, endOffset, primitiveOpSymbol.owner.returnType, origin, primitiveOpSymbol, argument1, argument2)
 
 fun IrGeneratorContext.constNull(startOffset: Int, endOffset: Int): IrExpression =
-    IrConstImpl.constNull(startOffset, endOffset, builtIns.nullableNothingType)
+    IrConstImpl.constNull(startOffset, endOffset, irBuiltIns.nothingNType)
 
 fun IrGeneratorContext.equalsNull(startOffset: Int, endOffset: Int, argument: IrExpression): IrExpression =
     primitiveOp2(
@@ -53,7 +54,19 @@ fun IrGeneratorContext.eqeqeq(startOffset: Int, endOffset: Int, argument1: IrExp
     primitiveOp2(startOffset, endOffset, irBuiltIns.eqeqeqSymbol, IrStatementOrigin.EQEQEQ, argument1, argument2)
 
 fun IrGeneratorContext.throwNpe(startOffset: Int, endOffset: Int, origin: IrStatementOrigin): IrExpression =
-    IrNullaryPrimitiveImpl(startOffset, endOffset, origin, irBuiltIns.throwNpeSymbol)
+    IrNullaryPrimitiveImpl(startOffset, endOffset, irBuiltIns.nothingType, origin, irBuiltIns.throwNpeSymbol)
+
+fun IrGeneratorContext.constTrue(startOffset: Int, endOffset: Int) =
+    IrConstImpl.constTrue(startOffset, endOffset, irBuiltIns.booleanType)
+
+fun IrGeneratorContext.constFalse(startOffset: Int, endOffset: Int) =
+    IrConstImpl.constFalse(startOffset, endOffset, irBuiltIns.booleanType)
+
+fun IrGeneratorContext.elseBranch(elseExpr: IrExpression): IrElseBranch {
+    val startOffset = elseExpr.startOffset
+    val endOffset = elseExpr.endOffset
+    return IrElseBranchImpl(startOffset, endOffset, constTrue(startOffset, endOffset), elseExpr)
+}
 
 // a || b == if (a) true else b
 fun IrGeneratorContext.oror(
@@ -63,11 +76,10 @@ fun IrGeneratorContext.oror(
     b: IrExpression,
     origin: IrStatementOrigin = IrStatementOrigin.OROR
 ): IrWhen =
-    IrIfThenElseImpl(
-        startOffset, endOffset, builtIns.booleanType,
-        a, IrConstImpl.constTrue(b.startOffset, b.endOffset, builtIns.booleanType), b,
-        origin
-    )
+    IrIfThenElseImpl(startOffset, endOffset, irBuiltIns.booleanType, origin).apply {
+        branches.add(IrBranchImpl(a, constTrue(a.startOffset, a.endOffset)))
+        branches.add(elseBranch(b))
+    }
 
 fun IrGeneratorContext.oror(a: IrExpression, b: IrExpression, origin: IrStatementOrigin = IrStatementOrigin.OROR): IrWhen =
     oror(b.startOffset, b.endOffset, a, b, origin)
@@ -83,11 +95,10 @@ fun IrGeneratorContext.andand(
     b: IrExpression,
     origin: IrStatementOrigin = IrStatementOrigin.ANDAND
 ): IrWhen =
-    IrIfThenElseImpl(
-        startOffset, endOffset, builtIns.booleanType,
-        a, b, IrConstImpl.constFalse(b.startOffset, b.endOffset, builtIns.booleanType),
-        origin
-    )
+    IrIfThenElseImpl(startOffset, endOffset, irBuiltIns.booleanType, origin).apply {
+        branches.add(IrBranchImpl(a, b))
+        branches.add(elseBranch(constFalse(b.startOffset, b.endOffset)))
+    }
 
 fun IrGeneratorContext.andand(a: IrExpression, b: IrExpression, origin: IrStatementOrigin = IrStatementOrigin.ANDAND): IrWhen =
     andand(b.startOffset, b.endOffset, a, b, origin)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/Scope.kt

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.createFunctionSymbol
+import org.jetbrains.kotlin.ir.types.impl.originalKotlinType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.KotlinType
 
@@ -42,7 +43,7 @@ class Scope(val scopeOwnerSymbol: IrSymbol) {
     private var lastTemporaryIndex: Int = 0
     private fun nextTemporaryIndex(): Int = lastTemporaryIndex++
 
-    fun createDescriptorForTemporaryVariable(
+    private fun createDescriptorForTemporaryVariable(
         type: KotlinType,
         nameHint: String? = null,
         isMutable: Boolean = false
@@ -59,12 +60,18 @@ class Scope(val scopeOwnerSymbol: IrSymbol) {
         nameHint: String? = null,
         isMutable: Boolean = false,
         origin: IrDeclarationOrigin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE
-    ): IrVariable =
-        IrVariableImpl(
+    ): IrVariable {
+        val originalKotlinType = irExpression.type.originalKotlinType ?: throw AssertionError("No originalKotlinType for $irExpression")
+        return IrVariableImpl(
             irExpression.startOffset, irExpression.endOffset, origin,
-            createDescriptorForTemporaryVariable(irExpression.type, nameHint, isMutable),
+            createDescriptorForTemporaryVariable(
+                originalKotlinType,
+                nameHint, isMutable
+            ),
+            irExpression.type,
             irExpression
         )
+    }
 }
 
 @Suppress("DeprecatedCallableAddReplaceWith")