Fix USELESS_IS_CHECK warnings in compiler code

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirUpperBoundViolatedHelpers.kt

@@ -33,11 +33,7 @@ fun checkUpperBoundViolated(
     isTypeAlias: Boolean = false,
     isIgnoreTypeParameters: Boolean = false
 ) {
-    val type = when (typeRef) {
+    val type = typeRef?.coneTypeSafe<ConeKotlinType>() ?: return
-        is ConeKotlinType -> typeRef
-        is FirResolvedTypeRef -> typeRef.type
-        else -> return
-    }
 
     val typeArgumentsCount = typeArguments?.size ?: type.typeArguments.size
     if (typeArgumentsCount == 0) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt

@@ -24,9 +24,6 @@ import org.jetbrains.kotlin.fir.packageFqName
 import org.jetbrains.kotlin.fir.resolve.fqName
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.StandardClassIds
-import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
-import org.jetbrains.kotlin.psi.KtDestructuringDeclarationEntry
-import org.jetbrains.kotlin.psi.KtLambdaExpression
 import org.jetbrains.kotlin.resolve.AnnotationTargetList
 import org.jetbrains.kotlin.resolve.AnnotationTargetLists
 
@@ -212,7 +209,6 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
             is FirEnumEntry -> AnnotationTargetList(
                 KotlinTarget.classActualTargets(ClassKind.ENUM_ENTRY, annotated.isInner, isCompanionObject = false, isLocalClass = false)
             )
-            is KtDestructuringDeclarationEntry -> TargetLists.T_LOCAL_VARIABLE
             is FirProperty -> {
                 when {
                     annotated.isLocal ->
@@ -248,8 +244,6 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
             is FirFile -> TargetLists.T_FILE
             is FirTypeParameter -> TargetLists.T_TYPE_PARAMETER
             is FirAnonymousInitializer -> TargetLists.T_INITIALIZER
-            is KtDestructuringDeclaration -> TargetLists.T_DESTRUCTURING_DECLARATION
-            is KtLambdaExpression -> TargetLists.T_FUNCTION_LITERAL
             is FirAnonymousObject ->
                 if (annotated.source?.kind == FirFakeSourceElementKind.EnumInitializer) {
                     AnnotationTargetList(
@@ -263,6 +257,10 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
                 } else {
                     TargetLists.T_OBJECT_LITERAL
                 }
+//            TODO: properly implement those cases
+//            is KtDestructuringDeclarationEntry -> TargetLists.T_LOCAL_VARIABLE
+//            is KtDestructuringDeclaration -> TargetLists.T_DESTRUCTURING_DECLARATION
+//            is KtLambdaExpression -> TargetLists.T_FUNCTION_LITERAL
             else -> TargetLists.EMPTY
         }
     }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
-import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -26,8 +25,6 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
 object FirCallableReferenceChecker : FirQualifiedAccessExpressionChecker() {
     override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) {
         if (expression !is FirCallableReferenceAccess) return
-        // [FirGetClassCallChecker] will check [FirGetClassCall].
-        if (expression is FirGetClassCall) return
 
         checkReferenceIsToAllowedMember(expression, context, reporter)
     }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirFunInterfaceConstructorReferenceChecker.kt

@@ -13,13 +13,14 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.utils.isFun
-import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
+import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 
 object FirFunInterfaceConstructorReferenceChecker : FirQualifiedAccessExpressionChecker() {
     override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (expression !is FirCallableReferenceAccess || expression is FirGetClassCall) return
+        if (expression !is FirCallableReferenceAccess) return
 
         val reference = expression.calleeReference as? FirResolvedNamedReference ?: return
         val referredSymbol = reference.resolvedSymbol

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantExplicitTypeChecker.kt

@@ -13,9 +13,8 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -33,7 +32,7 @@ object RedundantExplicitTypeChecker : FirPropertyChecker() {
 
         val type = declaration.returnTypeRef.coneType
 
-        if (typeReference is FirTypeAlias) return
+        if (type.toSymbol(context.session) is FirTypeAliasSymbol) return
         if (typeReference.annotations.isNotEmpty()) return
 
         when (initializer) {
@@ -65,9 +64,6 @@ object RedundantExplicitTypeChecker : FirPropertyChecker() {
                     else -> return
                 }
             }
-            is FirNamedReference -> {
-                if (!type.hasSameNameWithoutModifiers(initializer.name)) return
-            }
             is FirFunctionCall -> {
                 if (!type.hasSameNameWithoutModifiers(initializer.calleeReference.name)) return
             }

compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt

@@ -1517,7 +1517,6 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
                 is FirAnonymousFunctionExpression -> generate(expression.anonymousFunction, isStatement = false)
                 is FirUnitExpression -> generate(expression)
                 is FirStringConcatenationCall -> generate(expression)
-                is FirAnonymousFunction -> generate(expression, isStatement = false)
                 is FirThrowExpression -> generate(expression)
                 is FirWhenSubjectExpression -> generate(expression)
                 is FirElseIfTrueCondition -> generate(expression)
@@ -1557,7 +1556,6 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
                     generate(expression.expression)
                 }
                 is FirTypeOperatorCall -> generate(expression)
-                is FirAssignmentOperatorStatement -> generateBinary(expression.leftArgument, expression.rightArgument, expression.operation)
                 is FirEqualityOperatorCall -> generate(expression)
                 is FirBinaryLogicExpression -> generate(expression)
                 is FirCheckNotNullCall -> generate(expression)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirLocalVariableAssignmentAnalyzer.kt

@@ -302,7 +302,7 @@ internal class FirLocalVariableAssignmentAnalyzer(
                 with(functionCall) {
                     setOfNotNull(explicitReceiver, dispatchReceiver, extensionReceiver).forEach { it.accept(visitor, data) }
                     // Delay processing of lambda args because lambda body are evaluated after all arguments have been evaluated.
-                    val (postponedFunctionArgs, normalArgs) = argumentList.arguments.partition { it is FirAnonymousFunction }
+                    val (postponedFunctionArgs, normalArgs) = argumentList.arguments.partition { it is FirAnonymousFunctionExpression }
                     normalArgs.forEach { it.accept(visitor, data) }
                     postponedFunctionArgs.forEach { it.accept(visitor, data) }
                     calleeReference.accept(visitor, data)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt

@@ -113,7 +113,6 @@ class FirCallCompletionResultsWriterTransformer(
                 diagnostic =
                     when (declaration) {
                         is FirTypeParameter -> ConeTypeParameterInQualifiedAccess(declaration.symbol)
-                        is FirResolvedReifiedParameterReference -> ConeTypeParameterInQualifiedAccess(declaration.symbol)
                         else -> ConeSimpleDiagnostic("Callee reference to candidate without return type: ${declaration.render()}")
                     }
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt

@@ -181,7 +181,6 @@ open class FirTypeResolveTransformer(
     }
 
     override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Any?): FirTypeRef {
-        if (implicitTypeRef is FirImplicitBuiltinTypeRef) return transformTypeRef(implicitTypeRef, data)
         return implicitTypeRef
     }
 

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.kt

@@ -264,7 +264,6 @@ class PatternMatchingTypingVisitor internal constructor(facade: ExpressionTyping
             )
         } else {
             val illegalDeclarationString = when {
-                subjectVariable is KtDestructuringDeclaration -> "destructuring declaration"
                 subjectVariable.isVar -> "var"
                 subjectVariable.initializer == null -> "variable without initializer"
                 subjectVariable.hasDelegateExpression() -> "delegated property"