Fix NON_EXHAUSTIVE_WHEN_STATEMENT warnings in project code

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

@@ -58,6 +58,7 @@ interface FirDeclarationPresenter {
             is ConeKotlinType -> {
                 appendRepresentation(it)
             }
+            is ConeKotlinTypeConflictingProjection -> {}
         }
     }
 

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

@@ -197,6 +197,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
                             }
                     }
                 }
+                else -> {}
             }
             if (declarationName != null) {
                 session.lookupTracker?.recordLookup(

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

@@ -130,6 +130,7 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() {
                         }
                     }
                 }
+                else -> {}
             }
         }
 

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

@@ -37,6 +37,7 @@ object FirNestedClassChecker : FirRegularClassChecker() {
                     reporter.reportOn(declaration.source, NESTED_CLASS_NOT_ALLOWED, declaration.description, context)
                 }
             }
+            else -> {}
         }
     }
 

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

@@ -39,6 +39,7 @@ object FirProjectionRelationChecker : FirBasicDeclarationChecker() {
             }
             is FirTypeAlias ->
                 checkTypeRef(declaration.expandedTypeRef, context, reporter)
+            else -> {}
         }
     }
 

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

@@ -48,6 +48,7 @@ object FirReturnAllowedChecker : FirReturnExpressionChecker() {
                 }
                 is FirProperty -> if (!containingDeclaration.isLocal) return false
                 is FirValueParameter -> return true
+                else -> {}
             }
         }
         return true

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

@@ -857,6 +857,8 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
             }
             is ConeIntersectionType -> resolved { generate(type) }
             is ConeIntegerLiteralType -> inlineUnsupported(type)
+            is ConeLookupTagBasedType,
+            is ConeStubType -> {}
         }
         generateTypeArguments(type)
         if (type.isMarkedNullable) {

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -76,6 +76,7 @@ class FirElementSerializer private constructor(
                 is FirProperty -> propertyProto(declaration)?.let { builder.addProperty(it) }
                 is FirSimpleFunction -> functionProto(declaration)?.let { builder.addFunction(it) }
                 is FirTypeAlias -> typeAliasProto(declaration)?.let { builder.addTypeAlias(it) }
+                else -> {}
             }
         }
 
@@ -151,6 +152,7 @@ class FirElementSerializer private constructor(
                 is FirProperty -> propertyProto(declaration)?.let { builder.addProperty(it) }
                 is FirSimpleFunction -> functionProto(declaration)?.let { builder.addFunction(it) }
                 is FirEnumEntry -> enumEntryProto(declaration).let { builder.addEnumEntry(it) }
+                else -> {}
             }
         }
 

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

@@ -76,6 +76,7 @@ class Fir2IrConverter(
             when (it) {
                 is FirRegularClass -> processClassAndNestedClassHeaders(it)
                 is FirTypeAlias -> classifierStorage.registerTypeAlias(it, declarationStorage.getIrFile(file))
+                else -> {}
             }
         }
     }
@@ -107,6 +108,7 @@ class Fir2IrConverter(
                 when (declaration) {
                     is FirSimpleFunction -> processedCallableNames += declaration.name
                     is FirProperty -> processedCallableNames += declaration.name
+                    else -> {}
                 }
                 processMemberDeclaration(declaration, anonymousObject, irClass) ?: continue
             }

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

@@ -155,6 +155,7 @@ class Fir2IrDeclarationStorage(
                         constructorCache[declaration] = irConstructor
                     }
                 }
+                else -> {}
             }
         }
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt

@@ -249,6 +249,7 @@ private fun ConeClassifierLookupTag.enhanceMutability(
                 return ConeClassLikeLookupTagImpl(mutableId)
             }
         }
+        null -> {}
     }
 
     return this

compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/DescriptorUtils.kt

@@ -118,6 +118,7 @@ private fun StringBuilder.appendConeType(coneType: ConeKotlinType) {
         is ConeFlexibleType -> {
             appendConeType(coneType.lowerBound)
         }
+        else -> {}
     }
 }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt

@@ -265,6 +265,7 @@ private fun FirRegularClass.computeSamCandidateNames(session: FirSession): Set<N
                 is FirSimpleFunction -> if (declaration.modality == Modality.ABSTRACT) {
                     samCandidateNames.add(declaration.name)
                 }
+                else -> {}
             }
         }
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt

@@ -41,6 +41,7 @@ data class ArgumentMapping(
                 is ResolvedCallArgument.VarargArgument -> resolvedArgument.arguments.forEach {
                     argumentToParameterMapping[it] = valueParameter
                 }
+                ResolvedCallArgument.DefaultArgument -> {}
             }
         }
         return argumentToParameterMapping

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

@@ -293,11 +293,9 @@ abstract class AbstractFirStatusResolveTransformer(
         }
         return when (declaration) {
             is FirCallableDeclaration -> {
-                when (declaration) {
-                    is FirFunction -> {
-                        for (valueParameter in declaration.valueParameters) {
-                            transformValueParameter(valueParameter, data)
-                        }
+                if (declaration is FirFunction) {
+                    for (valueParameter in declaration.valueParameters) {
+                        transformValueParameter(valueParameter, data)
                     }
                 }
                 declaration
@@ -397,6 +395,7 @@ abstract class AbstractFirStatusResolveTransformer(
         when (superClass) {
             is FirRegularClass -> forceResolveStatusesOfClass(superClass)
             is FirTypeAlias -> forceResolveStatusOfCorrespondingClass(superClass.expandedTypeRef)
+            else -> {}
         }
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalClassGenerationProcessor.kt

@@ -59,6 +59,7 @@ class FirGlobalClassGenerationProcessor(
             when (owner) {
                 is FirRegularClass -> owner.addDeclaration(klass)
                 is FirFile -> owner.addDeclaration(klass)
+                else -> {}
             }
             session.generatedClassIndex.registerClass(klass, owner)
             session.predicateBasedProvider.registerGeneratedDeclaration(klass, owner)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt

@@ -33,16 +33,14 @@ class FirClassDeclaredMemberScope(
     private val callablesIndex: Map<Name, List<FirCallableSymbol<*>>> = run {
         val result = mutableMapOf<Name, MutableList<FirCallableSymbol<*>>>()
         loop@ for (declaration in klass.declarations) {
-            when (declaration) {
-                is FirCallableDeclaration -> {
-                    val name = when (declaration) {
-                        is FirConstructor -> CONSTRUCTOR_NAME
-                        is FirVariable -> if (declaration.isSynthetic) continue@loop else declaration.name
-                        is FirSimpleFunction -> declaration.name
-                        else -> continue@loop
-                    }
-                    result.getOrPut(name) { mutableListOf() } += declaration.symbol
+            if (declaration is FirCallableDeclaration) {
+                val name = when (declaration) {
+                    is FirConstructor -> CONSTRUCTOR_NAME
+                    is FirVariable -> if (declaration.isSynthetic) continue@loop else declaration.name
+                    is FirSimpleFunction -> declaration.name
+                    else -> continue@loop
                 }
+                result.getOrPut(name) { mutableListOf() } += declaration.symbol
             }
         }
         result

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -240,6 +240,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
                     print(callableDeclaration.symbol.callableId)
                 }
             }
+            else -> {}
         }
 
         if (callableDeclaration is FirFunction) {
@@ -382,6 +383,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
                     memberDeclaration.typeParameters.renderTypeParameters()
                 }
             }
+            else -> {}
         }
     }