[IR] Minor. Extract irBuiltins from IrGeneratorContext to separate interface

It's necessary to using some util functions on IrGeneratorContext in IrToFir

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

@@ -32,8 +32,7 @@ import org.jetbrains.kotlin.fir.types.render
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
-import org.jetbrains.kotlin.ir.builders.primitiveOp1
+import org.jetbrains.kotlin.ir.builders.*
-import org.jetbrains.kotlin.ir.builders.primitiveOp2
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.*
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
@@ -60,9 +59,9 @@ internal class Fir2IrVisitor(
     private val moduleDescriptor: FirModuleDescriptor,
     private val symbolTable: SymbolTable,
     private val sourceManager: PsiSourceManager,
-    private val irBuiltIns: IrBuiltIns,
+    override val irBuiltIns: IrBuiltIns,
     private val fakeOverrideMode: FakeOverrideMode
-) : FirVisitor<IrElement, Any?>() {
+) : FirVisitor<IrElement, Any?>(), IrGeneratorContextInterface {
     companion object {
         private val NEGATED_OPERATIONS: Set<FirOperation> = EnumSet.of(FirOperation.NOT_EQ, FirOperation.NOT_IDENTITY)
 

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

@@ -27,9 +27,11 @@ interface IrGeneratorWithScope : IrGenerator {
     val scope: Scope
 }
 
-abstract class IrGeneratorContext {
+interface IrGeneratorContextInterface {
-    abstract val irBuiltIns: IrBuiltIns
+    val irBuiltIns: IrBuiltIns
+}
 
+abstract class IrGeneratorContext : IrGeneratorContextInterface {
     val builtIns: KotlinBuiltIns get() = irBuiltIns.builtIns
 }
 

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

@@ -56,32 +56,32 @@ fun primitiveOp2(
         putValueArgument(1, argument2)
     }
 
-fun IrGeneratorContext.constNull(startOffset: Int, endOffset: Int): IrExpression =
+fun IrGeneratorContextInterface.constNull(startOffset: Int, endOffset: Int): IrExpression =
     IrConstImpl.constNull(startOffset, endOffset, irBuiltIns.nothingNType)
 
-fun IrGeneratorContext.equalsNull(startOffset: Int, endOffset: Int, argument: IrExpression): IrExpression =
+fun IrGeneratorContextInterface.equalsNull(startOffset: Int, endOffset: Int, argument: IrExpression): IrExpression =
     primitiveOp2(
         startOffset, endOffset, irBuiltIns.eqeqSymbol, irBuiltIns.booleanType, IrStatementOrigin.EQEQ,
         argument, constNull(startOffset, endOffset)
     )
 
-fun IrGeneratorContext.eqeqeq(startOffset: Int, endOffset: Int, argument1: IrExpression, argument2: IrExpression): IrExpression =
+fun IrGeneratorContextInterface.eqeqeq(startOffset: Int, endOffset: Int, argument1: IrExpression, argument2: IrExpression): IrExpression =
     primitiveOp2(startOffset, endOffset, irBuiltIns.eqeqeqSymbol, irBuiltIns.booleanType, IrStatementOrigin.EQEQEQ, argument1, argument2)
 
-fun IrGeneratorContext.constTrue(startOffset: Int, endOffset: Int) =
+fun IrGeneratorContextInterface.constTrue(startOffset: Int, endOffset: Int) =
     IrConstImpl.constTrue(startOffset, endOffset, irBuiltIns.booleanType)
 
-fun IrGeneratorContext.constFalse(startOffset: Int, endOffset: Int) =
+fun IrGeneratorContextInterface.constFalse(startOffset: Int, endOffset: Int) =
     IrConstImpl.constFalse(startOffset, endOffset, irBuiltIns.booleanType)
 
-fun IrGeneratorContext.elseBranch(elseExpr: IrExpression): IrElseBranch {
+fun IrGeneratorContextInterface.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(
+fun IrGeneratorContextInterface.oror(
     startOffset: Int,
     endOffset: Int,
     a: IrExpression,
@@ -93,14 +93,14 @@ fun IrGeneratorContext.oror(
         branches.add(elseBranch(b))
     }
 
-fun IrGeneratorContext.oror(a: IrExpression, b: IrExpression, origin: IrStatementOrigin = IrStatementOrigin.OROR): IrWhen =
+fun IrGeneratorContextInterface.oror(a: IrExpression, b: IrExpression, origin: IrStatementOrigin = IrStatementOrigin.OROR): IrWhen =
     oror(b.startOffset, b.endOffset, a, b, origin)
 
-fun IrGeneratorContext.whenComma(a: IrExpression, b: IrExpression): IrWhen =
+fun IrGeneratorContextInterface.whenComma(a: IrExpression, b: IrExpression): IrWhen =
     oror(a, b, IrStatementOrigin.WHEN_COMMA)
 
 // a && b == if (a) b else false
-fun IrGeneratorContext.andand(
+fun IrGeneratorContextInterface.andand(
     startOffset: Int,
     endOffset: Int,
     a: IrExpression,
@@ -112,5 +112,5 @@ fun IrGeneratorContext.andand(
         branches.add(elseBranch(constFalse(b.startOffset, b.endOffset)))
     }
 
-fun IrGeneratorContext.andand(a: IrExpression, b: IrExpression, origin: IrStatementOrigin = IrStatementOrigin.ANDAND): IrWhen =
+fun IrGeneratorContextInterface.andand(a: IrExpression, b: IrExpression, origin: IrStatementOrigin = IrStatementOrigin.ANDAND): IrWhen =
     andand(b.startOffset, b.endOffset, a, b, origin)