[IR] Add IR validation error on redundant implicit cast

^KT-80953

Author: vsukharev

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/phaser/IrValidationPhase.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.ir.validation.checkers.declaration.IrExpressionBodyI
 import org.jetbrains.kotlin.ir.validation.checkers.declaration.IrFieldVisibilityChecker
 import org.jetbrains.kotlin.ir.validation.checkers.expression.InlineFunctionUseSiteChecker
 import org.jetbrains.kotlin.ir.validation.checkers.expression.IrCrossFileFieldUsageChecker
+import org.jetbrains.kotlin.ir.validation.checkers.expression.IrTypeOperatorRedundancyChecker
 import org.jetbrains.kotlin.ir.validation.checkers.expression.IrValueAccessScopeChecker
 import org.jetbrains.kotlin.ir.validation.checkers.symbol.IrVisibilityChecker
 import org.jetbrains.kotlin.utils.addToStdlib.applyIf
@@ -106,6 +107,7 @@ class IrValidationAfterInliningAllFunctionsOnTheSecondStagePhase<Context : Lower
                 withVarargChecks()
             }
             .withInlineFunctionCallsiteCheck(checkInlineFunctionCallSites)
+            .withCheckers(IrTypeOperatorRedundancyChecker)
 }
 
 class IrValidationAfterInliningAllFunctionsOnTheFirstStagePhase<Context : LoweringContext>(

compiler/ir/ir.validation/src/org/jetbrains/kotlin/ir/validation/checkers/expression/IrTypeOperatorRedundancyChecker.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.ir.validation.checkers.expression
+
+import org.jetbrains.kotlin.ir.expressions.IrTypeOperator
+import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
+import org.jetbrains.kotlin.ir.util.render
+import org.jetbrains.kotlin.ir.validation.checkers.IrElementChecker
+import org.jetbrains.kotlin.ir.validation.checkers.context.CheckerContext
+
+object IrTypeOperatorRedundancyChecker : IrElementChecker<IrTypeOperatorCall>(IrTypeOperatorCall::class) {
+    override fun check(element: IrTypeOperatorCall, context: CheckerContext) {
+        if (element.operator == IrTypeOperator.IMPLICIT_CAST) {
+            if (element.type == element.argument.type) {
+                context.error(element, "Redundant IMPLICIT_CAST: ${element.render()}")
+            }
+        }
+    }
+}

compiler/ir/ir.validation/test/org/jetbrains/kotlin/ir/validation/IrValidatorTest.kt

@@ -39,6 +39,7 @@ import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.types.impl.IrDynamicTypeImpl
 import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
 import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.validation.checkers.expression.IrTypeOperatorRedundancyChecker
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
@@ -2231,6 +2232,62 @@ class IrValidatorTest {
         )
     }
 
+    @Test
+    fun `redundant IMPLICIT_CAST is reported`() {
+        val file = createIrFile("test.kt")
+        val function = IrFactoryImpl.buildFun {
+            name = Name.identifier("foo")
+            returnType = TestIrBuiltins.unitType
+        }
+        val body = IrFactoryImpl.createBlockBody(
+            startOffset = UNDEFINED_OFFSET,
+            endOffset = UNDEFINED_OFFSET,
+        )
+
+        // Redundant: result type equals argument type
+        val redundantImplicitCast = IrTypeOperatorCallImpl(
+            startOffset = UNDEFINED_OFFSET,
+            endOffset = UNDEFINED_OFFSET,
+            type = TestIrBuiltins.booleanType,
+            operator = IrTypeOperator.IMPLICIT_CAST,
+            typeOperand = TestIrBuiltins.booleanType,
+            argument = createTrueConst()
+        )
+
+        // Non-redundant: argument type differs from result type
+        val nonRedundantImplicitCast = IrTypeOperatorCallImpl(
+            startOffset = UNDEFINED_OFFSET,
+            endOffset = UNDEFINED_OFFSET,
+            type = TestIrBuiltins.anyType,
+            operator = IrTypeOperator.IMPLICIT_CAST,
+            typeOperand = TestIrBuiltins.anyType,
+            argument = createTrueConst() // Boolean is a subtype of Any
+        )
+
+        body.statements.addAll(listOf(redundantImplicitCast, nonRedundantImplicitCast))
+        function.body = body
+        file.addChild(function)
+
+        testValidation(
+            IrVerificationMode.ERROR,
+            file,
+            listOf(
+                Message(
+                    ERROR,
+                    """
+                    [IR VALIDATION] IrValidatorTest: Redundant IMPLICIT_CAST: TYPE_OP type=kotlin.Boolean origin=IMPLICIT_CAST typeOperand=kotlin.Boolean
+                    TYPE_OP type=kotlin.Boolean origin=IMPLICIT_CAST typeOperand=kotlin.Boolean
+                      inside BLOCK_BODY
+                        inside FUN name:foo visibility:public modality:FINAL <> () returnType:kotlin.Unit
+                          inside FILE fqName:org.sample fileName:test.kt
+                    """.trimIndent(),
+                    CompilerMessageLocation.create("test.kt", 0, 0, null),
+                )
+            ),
+            config = defaultValidationConfig.withCheckers(IrTypeOperatorRedundancyChecker)
+        )
+    }
+
     @Test
     fun `calls with incorrect type are reported`() {
         val file = createIrFile("test.kt")