IR: remove type parameter in visitConst

Co-authored-by: mcpiroman <mcpiroman@gmail.com>

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CheckIrElementVisitor.kt

@@ -75,7 +75,7 @@ class CheckIrElementVisitor(
         }
     }
 
-    override fun <T> visitConst(expression: IrConst<T>) {
+    override fun visitConst(expression: IrConst<*>) {
         super.visitConst(expression)
 
         @Suppress("UNUSED_VARIABLE")

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ConstLowering.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.ir.util.isUnsigned
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
 
-
 class ConstTransformer(private val context: JsIrBackendContext) : IrElementTransformerVoid() {
     private fun <C> lowerConst(
         irClass: IrClassSymbol,
@@ -44,7 +43,7 @@ class ConstTransformer(private val context: JsIrBackendContext) : IrElementTrans
     private fun createLong(v: Long): IrExpression =
         lowerConst(context.intrinsics.longClassSymbol, IrConstImpl.Companion::int, v.toInt(), (v shr 32).toInt())
 
-    override fun <T> visitConst(expression: IrConst<T>): IrExpression {
+    override fun visitConst(expression: IrConst<*>): IrExpression {
         with(context.intrinsics) {
             if (expression.type.isUnsigned() && expression.kind != IrConstKind.Null) {
                 return when (expression.type.classifierOrNull) {
@@ -76,4 +75,4 @@ class ConstLowering(private val context: JsIrBackendContext) : BodyLoweringPass
     override fun lower(irBody: IrBody, container: IrDeclaration) {
         irBody.transformChildrenVoid(ConstTransformer(context))
     }
-}
+}

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsExpressionTransformer.kt

@@ -8,7 +8,10 @@ package org.jetbrains.kotlin.ir.backend.js.transformers.irToJs
 import org.jetbrains.kotlin.backend.common.compilationException
 import org.jetbrains.kotlin.backend.common.ir.isElseBranch
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.ir.backend.js.utils.*
+import org.jetbrains.kotlin.ir.backend.js.utils.JsGenerationContext
+import org.jetbrains.kotlin.ir.backend.js.utils.Namer
+import org.jetbrains.kotlin.ir.backend.js.utils.emptyScope
+import org.jetbrains.kotlin.ir.backend.js.utils.getJsNameOrKotlinName
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.types.isString
@@ -50,7 +53,7 @@ class IrElementToJsExpressionTransformer : BaseIrElementToJsNodeTransformer<JsEx
         return irFunction.accept(IrFunctionToJsTransformer(), context).apply { name = null }
     }
 
-    override fun <T> visitConst(expression: IrConst<T>, context: JsGenerationContext): JsExpression {
+    override fun visitConst(expression: IrConst<*>, context: JsGenerationContext): JsExpression {
         val kind = expression.kind
         return when (kind) {
             is IrConstKind.String -> JsStringLiteral(kind.valueOf(expression))

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsCode.kt

@@ -89,7 +89,7 @@ fun foldString(expression: IrExpression, context: JsIrBackendContext): String? {
             expression.acceptChildrenVoid(this)
         }
 
-        override fun <T> visitConst(expression: IrConst<T>) {
+        override fun visitConst(expression: IrConst<*>) {
             builder.append(expression.kind.valueOf(expression))
         }
 
@@ -109,4 +109,4 @@ private class InitFunVisitor(private val context: JsIrBackendContext) : IrElemen
     override fun visitSetField(expression: IrSetField) {
         context.fieldToInitializer[expression.symbol.owner] = expression.value
     }
-}
+}

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

@@ -792,7 +792,7 @@ class ExpressionCodegen(
         return unitValue
     }
 
-    override fun <T> visitConst(expression: IrConst<T>, data: BlockInfo): PromisedValue {
+    override fun visitConst(expression: IrConst<*>, data: BlockInfo): PromisedValue {
         expression.markLineNumber(startOffset = true)
         when (val value = expression.value) {
             is Boolean -> {

compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt

@@ -12,7 +12,10 @@ import org.jetbrains.kotlin.backend.common.ir.isOverridable
 import org.jetbrains.kotlin.backend.common.ir.returnType
 import org.jetbrains.kotlin.backend.wasm.WasmBackendContext
 import org.jetbrains.kotlin.backend.wasm.WasmSymbols
-import org.jetbrains.kotlin.backend.wasm.utils.*
+import org.jetbrains.kotlin.backend.wasm.utils.getWasmArrayAnnotation
+import org.jetbrains.kotlin.backend.wasm.utils.getWasmOpAnnotation
+import org.jetbrains.kotlin.backend.wasm.utils.hasWasmNoOpCastAnnotation
+import org.jetbrains.kotlin.backend.wasm.utils.isCanonical
 import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.backend.js.utils.findUnitGetInstanceFunction
@@ -21,7 +24,10 @@ import org.jetbrains.kotlin.ir.backend.js.utils.realOverrideTarget
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.types.*
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.defaultType
+import org.jetbrains.kotlin.ir.util.getInlineClassBackingField
+import org.jetbrains.kotlin.ir.util.isInterface
+import org.jetbrains.kotlin.ir.util.parentAsClass
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
 import org.jetbrains.kotlin.wasm.ir.*
@@ -99,7 +105,7 @@ class BodyGenerator(val context: WasmFunctionCodegenContext) : IrElementVisitorV
         }
     }
 
-    override fun <T> visitConst(expression: IrConst<T>) {
+    override fun visitConst(expression: IrConst<*>) {
         when (val kind = expression.kind) {
             is IrConstKind.Null -> generateDefaultInitializerForType(context.transformType(expression.type), body)
             is IrConstKind.Boolean -> body.buildConstI32(if (kind.valueOf(expression)) 1 else 0)

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/checker/IrCompileTimeChecker.kt

@@ -13,7 +13,8 @@ import org.jetbrains.kotlin.ir.interpreter.accessesTopLevelOrObjectField
 import org.jetbrains.kotlin.ir.interpreter.fqName
 import org.jetbrains.kotlin.ir.interpreter.isAccessToObject
 import org.jetbrains.kotlin.ir.types.*
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.constructors
+import org.jetbrains.kotlin.ir.util.statements
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrCompileTimeChecker(
@@ -84,7 +85,7 @@ class IrCompileTimeChecker(
         return body.kind == IrSyntheticBodyKind.ENUM_VALUES || body.kind == IrSyntheticBodyKind.ENUM_VALUEOF
     }
 
-    override fun <T> visitConst(expression: IrConst<T>, data: Nothing?): Boolean {
+    override fun visitConst(expression: IrConst<*>, data: Nothing?): Boolean {
         if (expression.type.getUnsignedType() != null) {
             val constructor = expression.type.classOrNull?.owner?.constructors?.singleOrNull() ?: return false
             return mode.canEvaluateFunction(constructor)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import java.util.*
 
 inline fun <reified T : IrElement> T.deepCopyWithSymbols(
     initialParent: IrDeclarationParent? = null,
@@ -408,7 +407,7 @@ open class DeepCopyIrTreeWithSymbols(
     override fun visitExpression(expression: IrExpression): IrExpression =
         throw IllegalArgumentException("Unsupported expression type: $expression")
 
-    override fun <T> visitConst(expression: IrConst<T>): IrConst<T> =
+    override fun visitConst(expression: IrConst<*>): IrConst<*> =
         expression.shallowCopy().copyAttributes(expression)
 
     override fun visitConstantObject(expression: IrConstantObject): IrConstantValue =

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt

@@ -560,7 +560,7 @@ class RenderIrElementVisitor(private val normalizeNames: Boolean = false, privat
     override fun visitExpression(expression: IrExpression, data: Nothing?): String =
         "? ${expression::class.java.simpleName} type=${expression.type.render()}"
 
-    override fun <T> visitConst(expression: IrConst<T>, data: Nothing?): String =
+    override fun visitConst(expression: IrConst<*>, data: Nothing?): String =
         "CONST ${expression.kind} type=${expression.type.render()} value=${expression.value?.escapeIfRequired()}"
 
     private fun Any.escapeIfRequired() =

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/dumpKotlinLike.kt

@@ -1180,7 +1180,7 @@ private class KotlinLikeDumper(val p: Printer, val options: KotlinLikeDumpOption
         }
     }
 
-    override fun <T> visitConst(expression: IrConst<T>, data: IrDeclaration?) {
+    override fun visitConst(expression: IrConst<*>, data: IrDeclaration?) {
         val kind = expression.kind
 
         val (prefix, postfix) = when (kind) {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt

@@ -79,9 +79,9 @@ interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
         return expression
     }
 
-    override fun <T> visitConst(expression: IrConst<T>, data: D) = visitExpression(expression, data)
+    override fun visitConst(expression: IrConst<*>, data: D) = visitExpression(expression, data)
     override fun visitVararg(expression: IrVararg, data: D) = visitExpression(expression, data)
-    override fun visitConstantValue(expression: IrConstantValue, data: D) : IrConstantValue {
+    override fun visitConstantValue(expression: IrConstantValue, data: D): IrConstantValue {
         expression.transformChildren(this, data)
         return expression
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformerVoid.kt

@@ -134,10 +134,10 @@ abstract class IrElementTransformerVoid : IrElementTransformer<Nothing?> {
 
     final override fun visitExpression(expression: IrExpression, data: Nothing?): IrExpression = visitExpression(expression)
 
-    open fun <T> visitConst(expression: IrConst<T>) = visitExpression(expression)
-    final override fun <T> visitConst(expression: IrConst<T>, data: Nothing?) = visitConst(expression)
+    open fun visitConst(expression: IrConst<*>) = visitExpression(expression)
+    final override fun visitConst(expression: IrConst<*>, data: Nothing?) = visitConst(expression)
 
-    open fun visitConstantValue(expression: IrConstantValue) : IrConstantValue {
+    open fun visitConstantValue(expression: IrConstantValue): IrConstantValue {
         expression.transformChildren(this, null)
         return expression
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt

@@ -52,7 +52,7 @@ interface IrElementVisitor<out R, in D> {
     fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D) = visitExpression(expression, data)
 
     fun visitExpression(expression: IrExpression, data: D) = visitElement(expression, data)
-    fun <T> visitConst(expression: IrConst<T>, data: D) = visitExpression(expression, data)
+    fun visitConst(expression: IrConst<*>, data: D) = visitExpression(expression, data)
     fun visitConstantValue(expression: IrConstantValue, data: D) = visitExpression(expression, data)
     fun visitConstantObject(expression: IrConstantObject, data: D) = visitConstantValue(expression, data)
     fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D) = visitConstantValue(expression, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt

@@ -104,8 +104,8 @@ interface IrElementVisitorVoid : IrElementVisitor<Unit, Nothing?> {
     fun visitExpression(expression: IrExpression) = visitElement(expression)
     override fun visitExpression(expression: IrExpression, data: Nothing?) = visitExpression(expression)
 
-    fun <T> visitConst(expression: IrConst<T>) = visitExpression(expression)
-    override fun <T> visitConst(expression: IrConst<T>, data: Nothing?) = visitConst(expression)
+    fun visitConst(expression: IrConst<*>) = visitExpression(expression)
+    override fun visitConst(expression: IrConst<*>, data: Nothing?) = visitConst(expression)
 
     fun visitConstantValue(expression: IrConstantValue) = visitExpression(expression)
     override fun visitConstantValue(expression: IrConstantValue, data: Nothing?) = visitConstantValue(expression)

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/FileInitializersOptimization.kt

@@ -17,9 +17,6 @@ import org.jetbrains.kotlin.backend.konan.ir.isUnconditional
 import org.jetbrains.kotlin.backend.konan.ir.isVirtualCall
 import org.jetbrains.kotlin.backend.konan.logMultiple
 import org.jetbrains.kotlin.backend.konan.lower.*
-import org.jetbrains.kotlin.backend.konan.lower.DECLARATION_ORIGIN_FILE_GLOBAL_INITIALIZER
-import org.jetbrains.kotlin.backend.konan.lower.DECLARATION_ORIGIN_FILE_STANDALONE_THREAD_LOCAL_INITIALIZER
-import org.jetbrains.kotlin.backend.konan.lower.DECLARATION_ORIGIN_FILE_THREAD_LOCAL_INITIALIZER
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope
@@ -29,7 +26,10 @@ import org.jetbrains.kotlin.ir.declarations.lazy.IrLazyClass
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.symbols.IrReturnTargetSymbol
 import org.jetbrains.kotlin.ir.util.*
-import org.jetbrains.kotlin.ir.visitors.*
+import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
+import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
+import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
+import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
 import java.util.*
 
 /*
@@ -310,7 +310,7 @@ internal object FileInitializersOptimization {
                 override fun visitDeclaration(declaration: IrDeclarationBase, data: BitSet): BitSet = TODO(declaration.render())
 
                 override fun visitTypeOperator(expression: IrTypeOperatorCall, data: BitSet) = expression.argument.accept(this, data)
-                override fun <T> visitConst(expression: IrConst<T>, data: BitSet) = data
+                override fun visitConst(expression: IrConst<*>, data: BitSet) = data
                 override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: BitSet) = data
 
                 override fun visitGetValue(expression: IrGetValue, data: BitSet) = data
@@ -632,4 +632,4 @@ internal object FileInitializersOptimization {
         context.log { "Removed ${(numberOfCallSitesWithExtractedGlobalInitializerCall) * 100.0 / numberOfCallSitesToFunctionsWithGlobalInitializerCall}% global initializer calls" }
         context.log { "Removed ${(numberOfCallSitesWithExtractedThreadLocalInitializerCall) * 100.0 / numberOfCallSitesToFunctionsWithThreadLocalInitializerCall}% thread local initializer calls" }
     }
-}
+}