K2: Remove a bunch of unused declarations

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -1592,12 +1592,6 @@ private inline fun <reified P : PsiElement> AbstractDiagnosticGroup.exposedVisib
     return error<P>(positioningStrategy, exposedVisibilityDiagnosticInit)
 }
 
-private inline fun <reified P : PsiElement> AbstractDiagnosticGroup.exposedVisibilityWarning(
-    positioningStrategy: PositioningStrategy = PositioningStrategy.DEFAULT
-): PropertyDelegateProvider<Any?, ReadOnlyProperty<AbstractDiagnosticGroup, RegularDiagnosticData>> {
-    return warning<P>(positioningStrategy, exposedVisibilityDiagnosticInit)
-}
-
 private inline fun <reified P : PsiElement> AbstractDiagnosticGroup.exposedVisibilityDeprecationError(
     languageFeature: LanguageFeature,
     positioningStrategy: PositioningStrategy = PositioningStrategy.DEFAULT

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/model/RegularDiagnosticData.kt

@@ -81,13 +81,10 @@ enum class PositioningStrategy(private val strategy: String? = null) {
     RETURN_WITH_LABEL,
     PROPERTY_INITIALIZER,
     WHOLE_ELEMENT,
-    INT_LITERAL_OUT_OF_RANGE,
-    FLOAT_LITERAL_OUT_OF_RANGE,
     LONG_LITERAL_SUFFIX,
     REIFIED_MODIFIER,
     TYPE_PARAMETERS_LIST,
     FUN_MODIFIER,
-    SUSPEND_MODIFIER,
     FUN_INTERFACE,
     NAME_IDENTIFIER,
     QUESTION_MARK_BY_TYPE,

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/util/DeclaredVariableCollector.kt

@@ -34,10 +34,6 @@ class DeclaredVariableCollector {
         declaredVariablesPerElement.removeKey(statement)
     }
 
-    fun resetState() {
-        declaredVariablesPerElement.clear()
-    }
-
     // FirStatement -- closest statement (loop/lambda/local declaration) which may contain reassignments
     private val visitor = object : FirVisitor<Unit, FirStatement?>() {
         override fun visitElement(element: FirElement, data: FirStatement?) {

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

@@ -190,16 +190,6 @@ fun CheckerContext.findClosestClassOrObject(): FirClass? {
     return null
 }
 
-/**
- * Returns the list of functions that overridden by given
- */
-fun FirSimpleFunction.overriddenFunctions(
-    containingClass: FirClassSymbol<*>,
-    context: CheckerContext,
-): List<FirFunctionSymbol<*>> {
-    return symbol.overriddenFunctions(containingClass, context)
-}
-
 fun FirNamedFunctionSymbol.overriddenFunctions(
     containingClass: FirClassSymbol<*>,
     context: CheckerContext,

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

@@ -5,20 +5,11 @@
 
 package org.jetbrains.kotlin.fir.analysis.checkers
 
-import com.intellij.lang.LighterASTNode
-import com.intellij.openapi.util.Ref
-import com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.psi.KtModifierList
-import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType
 
-/**
- * Returns the visibility by given KtModifierList
- */
-fun KtModifierList?.getVisibility() = this?.visibilityModifierType()?.toVisibilityOrNull()
 
 /**
  * Returns Visibility by token or null

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

@@ -11,9 +11,9 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiNameIdentifierOwner
 import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.*
-import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.diagnostics.getAncestors
 import org.jetbrains.kotlin.diagnostics.nameIdentifier
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -54,8 +54,6 @@ interface SourceNavigator {
         }
 
         inline fun <R> FirElement.withNavigator(block: SourceNavigator.() -> R): R = with(forSource(this.source), block)
-
-        inline fun <R> KtSourceElement.withNavigator(block: SourceNavigator.() -> R): R = with(forSource(this), block)
     }
 }
 

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

@@ -14,8 +14,11 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef
+import org.jetbrains.kotlin.fir.types.isNullable
+import org.jetbrains.kotlin.fir.types.typeContext
 
 internal fun isInsideExpectClass(containingClass: FirClass, context: CheckerContext): Boolean {
     return isInsideSpecificClass(containingClass, context) { klass -> klass is FirRegularClass && klass.isExpect }
@@ -90,9 +93,6 @@ internal val FirBasedSymbol<*>.isLocalMember: Boolean
         else -> false
     }
 
-internal val FirCallableDeclaration.isExtensionMember: Boolean
-    get() = symbol.isExtensionMember
-
 internal val FirCallableSymbol<*>.isExtensionMember: Boolean
     get() = resolvedReceiverTypeRef != null && dispatchReceiverType != null
 

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

@@ -121,8 +121,4 @@ object FirBreakOrContinueJumpsAcrossFunctionBoundaryChecker : FirLoopJumpChecker
         findPathAndCheck(expression.target.labeledElement.block)
     }
 
-    private fun FirExpression.tryInline(): FirExpression {
-        val anonymousFunctionExpression = (((this as? FirLambdaArgumentExpression)?.expression) ?: this) as? FirAnonymousFunctionExpression
-        return anonymousFunctionExpression?.anonymousFunction?.body ?: this
-    }
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt

@@ -174,13 +174,4 @@ object FirDiagnosticRenderers {
     }
 
     val FUNCTIONAL_TYPE_KINDS = KtDiagnosticRenderers.COLLECTION(FUNCTIONAL_TYPE_KIND)
-
-    @Suppress("FunctionName")
-    fun <T> COLLECTION(renderer: ContextIndependentParameterRenderer<T>): ContextIndependentParameterRenderer<Collection<T>> {
-        return Renderer { list ->
-            list.joinToString(prefix = "[", postfix = "]", separator = ", ", limit = 3, truncated = "...") {
-                renderer.render(it)
-            }
-        }
-    }
 }

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/CompilerConeAttributes.kt

@@ -131,13 +131,6 @@ val ConeAttributes.enhancedNullability: CompilerConeAttributes.EnhancedNullabili
 val ConeAttributes.extensionFunctionType: CompilerConeAttributes.ExtensionFunctionType? by ConeAttributes.attributeAccessor<CompilerConeAttributes.ExtensionFunctionType>()
 private val ConeAttributes.contextFunctionTypeParams: CompilerConeAttributes.ContextFunctionTypeParams? by ConeAttributes.attributeAccessor<CompilerConeAttributes.ContextFunctionTypeParams>()
 
-val ConeAttributes.unsafeVarianceType: CompilerConeAttributes.UnsafeVariance? by ConeAttributes.attributeAccessor<CompilerConeAttributes.UnsafeVariance>()
-
-// ------------------------------------------------------------------
-
-val ConeAttributes.hasEnhancedNullability: Boolean
-    get() = enhancedNullability != null
-
 // ------------------------------------------------------------------
 
 val ConeKotlinType.hasEnhancedNullability: Boolean

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeBuiltinTypeUtils.kt

@@ -58,10 +58,6 @@ val ConeKotlinType.isPrimitiveArray: Boolean
 val ConeKotlinType.isUnsignedTypeOrNullableUnsignedType: Boolean get() = isAnyOfBuiltinType(StandardClassIds.unsignedTypes)
 val ConeKotlinType.isUnsignedType: Boolean get() = isUnsignedTypeOrNullableUnsignedType && nullability == ConeNullability.NOT_NULL
 
-val ConeKotlinType.isIntegerTypeOrNullableIntegerTypeOfAnySize: Boolean get() = isAnyOfBuiltinType(builtinIntegerTypes)
-
-private val builtinIntegerTypes = setOf(StandardClassIds.Int, StandardClassIds.Byte, StandardClassIds.Long, StandardClassIds.Short)
-
 private fun ConeKotlinType.isBuiltinType(classId: ClassId, isNullable: Boolean?): Boolean {
     if (this !is ConeClassLikeType) return false
     return lookupTag.classId == classId && (isNullable == null || type.isNullable == isNullable)

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirModuleInfoBasedModuleData.kt

@@ -1,45 +0,0 @@
-/*
- * Copyright 2010-2021 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.fir.session
-
-import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.TargetPlatform
-import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
-
-class FirModuleInfoBasedModuleData(val moduleInfo: ModuleInfo) : FirModuleData() {
-    override val name: Name
-        get() = moduleInfo.name
-
-    override val dependencies: List<FirModuleData> by lazy {
-        moduleInfo.dependencies()
-            .filterNot { it == moduleInfo }
-            .map { FirModuleInfoBasedModuleData(it) }
-    }
-
-    override val dependsOnDependencies: List<FirModuleData> = moduleInfo.expectedBy
-        .filterNot { it == moduleInfo }
-        .map { FirModuleInfoBasedModuleData(it) }
-
-    override val friendDependencies: List<FirModuleData> = moduleInfo.modulesWhoseInternalsAreVisible()
-        .filterNot { it == moduleInfo }
-        .map { FirModuleInfoBasedModuleData(it) }
-    override val platform: TargetPlatform
-        get() = moduleInfo.platform
-
-    override val analyzerServices: PlatformDependentAnalyzerServices
-        get() = moduleInfo.analyzerServices
-
-    override fun equals(other: Any?): Boolean {
-        if (other !is FirModuleInfoBasedModuleData) return false
-        return moduleInfo == other.moduleInfo
-    }
-
-    override fun hashCode(): Int {
-        return moduleInfo.hashCode()
-    }
-}

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ModuleDataProvider.kt

@@ -60,11 +60,3 @@ class MultipleModuleDataProvider(private val moduleDataWithFilters: Map<FirModul
     }
 }
 
-class EmptyModuleDataProvider(
-    override val platform: TargetPlatform,
-    override val analyzerServices: PlatformDependentAnalyzerServices
-) : ModuleDataProvider() {
-    override val allModuleData: Collection<FirModuleData> get() = emptyList()
-
-    override fun getModuleData(path: Path?): FirModuleData? = null
-}

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

@@ -32,11 +32,14 @@ import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping
 import org.jetbrains.kotlin.fir.extensions.extensionService
 import org.jetbrains.kotlin.fir.extensions.typeAttributeExtensions
-import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
+import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope
-import org.jetbrains.kotlin.fir.serialization.constant.*
+import org.jetbrains.kotlin.fir.serialization.constant.hasConstantValue
+import org.jetbrains.kotlin.fir.serialization.constant.toConstantValue
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
@@ -1100,9 +1103,6 @@ class FirElementSerializer private constructor(
         return writeLanguageVersionRequirement(languageFeature, this)
     }
 
-    private fun MutableVersionRequirementTable.writeCompilerVersionRequirement(major: Int, minor: Int, patch: Int): Int =
-        writeCompilerVersionRequirement(major, minor, patch, this)
-
     private fun MutableVersionRequirementTable.writeVersionRequirementDependingOnCoroutinesVersion(): Int =
         writeVersionRequirement(LanguageFeature.ReleaseCoroutines)
 
@@ -1273,17 +1273,6 @@ class FirElementSerializer private constructor(
             )
         }
 
-        fun writeCompilerVersionRequirement(
-            major: Int,
-            minor: Int,
-            patch: Int,
-            versionRequirementTable: MutableVersionRequirementTable
-        ): Int = writeVersionRequirement(
-            major, minor, patch,
-            ProtoBuf.VersionRequirement.VersionKind.COMPILER_VERSION,
-            versionRequirementTable
-        )
-
         fun writeVersionRequirement(
             major: Int,
             minor: Int,

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/ConstantValueUtils.kt

@@ -11,13 +11,10 @@ import org.jetbrains.kotlin.constant.ConstantValue
 import org.jetbrains.kotlin.constant.ErrorValue
 import org.jetbrains.kotlin.constant.KClassValue
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.resolve.defaultType
-import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
@@ -53,21 +50,6 @@ inline fun <reified T : ConeKotlinType> KClassValue.Value.LocalClass.coneType():
     return this.type as T
 }
 
-internal fun KClassValue.getArgumentType(session: FirSession): ConeKotlinType? {
-    when (val castedValue = value) {
-        is KClassValue.Value.LocalClass -> return castedValue.type as ConeKotlinType
-        is KClassValue.Value.NormalClass -> {
-            val (classId, arrayDimensions) = castedValue.value
-            val klass = session.symbolProvider.getClassLikeSymbolByClassId(classId)?.fir as? FirRegularClass ?: return null
-            var type: ConeClassLikeType = klass.defaultType().replaceArgumentsWithStarProjections()
-            repeat(arrayDimensions) {
-                type = type.createArrayType()
-            }
-            return type
-        }
-    }
-}
-
 internal fun create(argumentType: ConeKotlinType): ConstantValue<*>? {
     if (argumentType is ConeErrorType) return null
     if (argumentType !is ConeClassLikeType) return null

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmTypeMapper.kt

@@ -14,9 +14,7 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.declarations.utils.isInner
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.resolve.defaultType
@@ -34,7 +32,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
-import org.jetbrains.kotlin.name.*
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.SpecialNames
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.types.AbstractTypeMapper
 import org.jetbrains.kotlin.types.TypeMappingContext
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
@@ -224,10 +224,6 @@ class FirJvmTypeMapper(val session: FirSession) : FirSessionComponent {
         fun segments(): List<PossiblyInnerConeType> = outerType?.segments().orEmpty() + this
     }
 
-    fun getJvmShortName(klass: FirRegularClass): String {
-        return getJvmShortName(klass.classId)
-    }
-
     internal fun getJvmShortName(classId: ClassId): String {
         val result = runUnless(classId.isLocal) {
             classId.asSingleFqName().toUnsafe().let { JavaToKotlinClassMap.mapKotlinToJava(it)?.shortClassName?.asString() }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt

@@ -11,12 +11,14 @@ import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
-import org.jetbrains.kotlin.fir.scopes.*
-import org.jetbrains.kotlin.fir.delegatedWrapperData
 import org.jetbrains.kotlin.fir.resolve.scope
+import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.types.coneType
+import org.jetbrains.kotlin.fir.types.lowerBoundIfFlexible
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
@@ -78,16 +80,6 @@ class DelegatedMemberGenerator(private val components: Fir2IrComponents) : Fir2I
         bodiesInfo.clear()
     }
 
-    private fun FirClassifierSymbol<*>?.boundClass(): FirClass {
-        return when (this) {
-            is FirRegularClassSymbol -> fir
-            is FirAnonymousObjectSymbol -> fir
-            is FirTypeParameterSymbol ->
-                fir.bounds.first().coneType.fullyExpandedType(session).lowerBoundIfFlexible().toSymbol(session).boundClass()
-            is FirTypeAliasSymbol, null -> throw AssertionError(this?.fir?.render())
-        }
-    }
-
     // Generate delegated members for [subClass]. The synthetic field [irField] has the super interface type.
     fun generate(irField: IrField, firField: FirField, firSubClass: FirClass, subClass: IrClass) {
         val subClassScope = firSubClass.unsubstitutedScope(

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt

@@ -154,7 +154,6 @@ class FirJavaClassBuilder : FirRegularClassBuilder(), FirAnnotationContainerBuil
     var isFromSource: Boolean by Delegates.notNull()
     var isTopLevel: Boolean by Delegates.notNull()
     var isStatic: Boolean by Delegates.notNull()
-    var isNotSam: Boolean by Delegates.notNull()
     var javaPackage: JavaPackage? = null
     lateinit var javaTypeParameterStack: JavaTypeParameterStack
     val existingNestedClassifierNames: MutableList<Name> = mutableListOf()

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt

@@ -27,19 +27,6 @@ import org.jetbrains.kotlin.fir.visitors.transformInplace
 import org.jetbrains.kotlin.fir.visitors.transformSingle
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
-import org.jetbrains.kotlin.util.OperatorNameConventions.ASSIGNMENT_OPERATIONS
-import org.jetbrains.kotlin.util.OperatorNameConventions.BINARY_OPERATION_NAMES
-import org.jetbrains.kotlin.util.OperatorNameConventions.COMPARE_TO
-import org.jetbrains.kotlin.util.OperatorNameConventions.CONTAINS
-import org.jetbrains.kotlin.util.OperatorNameConventions.DELEGATED_PROPERTY_OPERATORS
-import org.jetbrains.kotlin.util.OperatorNameConventions.EQUALS
-import org.jetbrains.kotlin.util.OperatorNameConventions.GET
-import org.jetbrains.kotlin.util.OperatorNameConventions.HAS_NEXT
-import org.jetbrains.kotlin.util.OperatorNameConventions.INVOKE
-import org.jetbrains.kotlin.util.OperatorNameConventions.ITERATOR
-import org.jetbrains.kotlin.util.OperatorNameConventions.NEXT
-import org.jetbrains.kotlin.util.OperatorNameConventions.SET
-import org.jetbrains.kotlin.util.OperatorNameConventions.UNARY_OPERATION_NAMES
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -188,10 +175,6 @@ class FirJavaMethod @FirImplementationDetail constructor(
     }
 }
 
-val ALL_JAVA_OPERATION_NAMES =
-    UNARY_OPERATION_NAMES + BINARY_OPERATION_NAMES + ASSIGNMENT_OPERATIONS + DELEGATED_PROPERTY_OPERATORS +
-            EQUALS + COMPARE_TO + CONTAINS + INVOKE + ITERATOR + GET + SET + NEXT + HAS_NEXT
-
 @FirBuilderDsl
 class FirJavaMethodBuilder : FirFunctionBuilder, FirTypeParametersOwnerBuilder, FirAnnotationContainerBuilder {
     override var source: KtSourceElement? = null

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaScopeUtils.kt

@@ -78,23 +78,6 @@ object BuiltinMethodsWithSpecialGenericSignature {
 
     val Name.sameAsBuiltinMethodWithErasedValueParameters: Boolean
         get() = this in ERASED_VALUE_PARAMETERS_SHORT_NAMES
-
-    fun FirNamedFunctionSymbol.isBuiltinWithSpecialDescriptorInJvm(containingScope: FirTypeScope, session: FirSession): Boolean {
-        if (!isFromBuiltinClass(session)) return false
-        return getSpecialSignatureInfo(containingScope)?.isObjectReplacedWithTypeParameter ?: false ||
-                doesOverrideBuiltinWithDifferentJvmName(containingScope, session)
-    }
-
-    @JvmStatic
-    fun FirNamedFunctionSymbol.getSpecialSignatureInfo(containingScope: FirTypeScope): SpecialGenericSignatures.SpecialSignatureInfo? {
-        if (name !in ERASED_VALUE_PARAMETERS_SHORT_NAMES) return null
-
-        val builtinSignature = firstOverriddenFunction(containingScope) { it.hasErasedValueParametersInJava }
-            ?.fir
-            ?.computeJvmSignature()
-            ?: return null
-        return SpecialGenericSignatures.getSpecialSignatureInfo(builtinSignature)
-    }
 }
 
 object BuiltinMethodsWithDifferentJvmName {

compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/AbstractModularizedTest.kt

@@ -34,7 +34,6 @@ data class ModuleData(
 ) {
     val qualifiedName get() = if (name in qualifier) qualifier else "$name.$qualifier"
 
-    val outputDir = rawOutputDir.fixPath()
     val classpath = rawClasspath.map { it.fixPath() }
     val sources = rawSources.map { it.fixPath() }
     val javaSourceRoots = rawJavaSourceRoots.map { JavaSourceRootData(it.path.fixPath(), it.packagePrefix) }

compiler/fir/providers/src/org/jetbrains/kotlin/fir/CopyUtils.kt

@@ -7,9 +7,7 @@ package org.jetbrains.kotlin.fir
 
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId
 import org.jetbrains.kotlin.fir.declarations.utils.expandedConeType
-import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.FirImplicitInvokeCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.buildImplicitInvokeCall
@@ -64,15 +62,6 @@ fun FirTypeRef.resolvedTypeFromPrototype(
     }
 }
 
-fun FirTypeRef.errorTypeFromPrototype(
-    diagnostic: ConeDiagnostic
-): FirErrorTypeRef {
-    return buildErrorTypeRef {
-        source = this@errorTypeFromPrototype.source
-        this.diagnostic = diagnostic
-    }
-}
-
 /**
  * [shouldExpandTypeAliases] should be set to `false` if this function is called during deserialization of some binary declaration
  * For details see KT-57876

compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt

@@ -223,7 +223,6 @@ fun FirAnnotation.findArgumentByName(name: Name): FirExpression? {
 
 fun FirAnnotation.getBooleanArgument(name: Name): Boolean? = getPrimitiveArgumentValue(name)
 fun FirAnnotation.getStringArgument(name: Name): String? = getPrimitiveArgumentValue(name)
-fun FirAnnotation.getIntArgument(name: Name): Int? = getPrimitiveArgumentValue(name)
 fun FirAnnotation.getStringArrayArgument(name: Name): List<String>? {
     val argument = findArgumentByName(name) as? FirArrayOfCall ?: return null
     return argument.arguments.mapNotNull { (it as? FirConstExpression<*>)?.value as? String }

compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/contractSubstitutions.kt

@@ -6,10 +6,6 @@
 package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirEffectDeclaration
-import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription
-import org.jetbrains.kotlin.fir.contracts.builder.buildEffectDeclaration
-import org.jetbrains.kotlin.fir.contracts.builder.buildResolvedContractDescription
 import org.jetbrains.kotlin.fir.contracts.description.*
 import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -17,31 +13,6 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 val FirContractDescription?.isNullOrEmpty: Boolean
     get() = (this == null) || (this is FirEmptyContractDescription)
 
-fun FirContractDescription.createContractDescriptionForSubstitutionOverride(substitutor: ConeSubstitutor?): FirContractDescription {
-    if (this !is FirResolvedContractDescription) return this
-    if (substitutor == null || substitutor == ConeSubstitutor.Empty) return this
-    return createContractDescriptionForSubstitutionOverride(substitutor)
-}
-
-private fun FirResolvedContractDescription.createContractDescriptionForSubstitutionOverride(
-    substitutor: ConeSubstitutor
-): FirResolvedContractDescription {
-    val original = this
-    return buildResolvedContractDescription {
-        source = original.source
-        original.effects.mapTo(effects) { it.substitute(substitutor) }
-        unresolvedEffects.addAll(original.unresolvedEffects)
-    }
-}
-
-private fun FirEffectDeclaration.substitute(substitutor: ConeSubstitutor): FirEffectDeclaration {
-    val original = this
-    return buildEffectDeclaration {
-        source = original.source
-        effect = original.effect.substitute(substitutor)
-    }
-}
-
 private fun ConeEffectDeclaration.substitute(substitutor: ConeSubstitutor): ConeEffectDeclaration {
     return when (this) {
         is ConeConditionalEffectDeclaration -> ConeConditionalEffectDeclaration(

compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/declarationUtils.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.fir.types.toSymbol
-import org.jetbrains.kotlin.utils.addToStdlib.runIf
 
 fun FirClass.constructors(session: FirSession): List<FirConstructorSymbol> {
     val result = mutableListOf<FirConstructorSymbol>()
@@ -26,10 +25,6 @@ fun FirClass.constructors(session: FirSession): List<FirConstructorSymbol> {
     return result
 }
 
-fun FirClass.constructorsSortedByDelegation(session: FirSession): List<FirConstructorSymbol> {
-    return constructors(session).sortedWith(ConstructorDelegationComparator)
-}
-
 fun FirClass.primaryConstructorIfAny(session: FirSession): FirConstructorSymbol? {
     return constructors(session).find(FirConstructorSymbol::isPrimary)
 }
@@ -44,23 +39,6 @@ fun FirClassSymbol<*>.collectEnumEntries(): Collection<FirEnumEntrySymbol> {
     return fir.collectEnumEntries().map { it.symbol }
 }
 
-val FirConstructorSymbol.delegatedThisConstructor: FirConstructorSymbol?
-    get() = runIf(delegatedConstructorCallIsThis) { this.resolvedDelegatedConstructor }
-
-
-private object ConstructorDelegationComparator : Comparator<FirConstructorSymbol> {
-    override fun compare(p0: FirConstructorSymbol?, p1: FirConstructorSymbol?): Int {
-        if (p0 == null && p1 == null) return 0
-        if (p0 == null) return -1
-        if (p1 == null) return 1
-        if (p0.delegatedThisConstructor == p1) return 1
-        if (p1.delegatedThisConstructor == p0) return -1
-        // If neither is a delegation to each other, the order doesn't matter.
-        // Here we return 0 to preserve the original order.
-        return 0
-    }
-}
-
 /**
  * Returns the FirClassLikeDeclaration that the
  * sequence of FirTypeAlias'es points to starting
@@ -80,11 +58,6 @@ fun FirBasedSymbol<*>.isAnnotationConstructor(session: FirSession): Boolean {
     return getConstructedClass(session)?.classKind == ClassKind.ANNOTATION_CLASS
 }
 
-fun FirBasedSymbol<*>.isEnumConstructor(session: FirSession): Boolean {
-    if (this !is FirConstructorSymbol) return false
-    return getConstructedClass(session)?.classKind == ClassKind.ENUM_CLASS
-}
-
 fun FirBasedSymbol<*>.isPrimaryConstructorOfInlineOrValueClass(session: FirSession): Boolean {
     if (this !is FirConstructorSymbol) return false
     return getConstructedClass(session)?.isInlineOrValueClass() == true && this.isPrimary

compiler/fir/providers/src/org/jetbrains/kotlin/fir/extensions/FirDeclarationGenerationExtension.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.extensions
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.caches.FirCache
 import org.jetbrains.kotlin.fir.caches.FirLazyValue
 import org.jetbrains.kotlin.fir.caches.firCachesFactory
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
@@ -78,12 +77,6 @@ abstract class FirDeclarationGenerationExtension(session: FirSession) : FirExten
 
     // ----------------------------------- internal utils -----------------------------------
 
-    @FirExtensionApiInternals
-    val nestedClassifierNamesCache: FirCache<FirClassSymbol<*>, Set<Name>, NestedClassGenerationContext> =
-        session.firCachesFactory.createCache { symbol, context ->
-            getNestedClassifiersNames(symbol, context)
-        }
-
     @FirExtensionApiInternals
     val topLevelClassIdsCache: FirLazyValue<Set<ClassId>> =
         session.firCachesFactory.createLazyValue { getTopLevelClassIds() }

compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt

@@ -47,9 +47,6 @@ fun ConeClassLikeLookupTag.toSymbol(useSiteSession: FirSession): FirClassLikeSym
     }
 }
 
-fun ConeClassLikeLookupTag.toSymbolOrError(useSiteSession: FirSession): FirClassLikeSymbol<*> =
-    toSymbol(useSiteSession) ?: error("Class symbol with classId $classId was not found")
-
 fun ConeClassLikeLookupTag.toFirRegularClassSymbol(session: FirSession): FirRegularClassSymbol? =
     toSymbol(session) as? FirRegularClassSymbol
 

compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/FirKotlinScopeProvider.kt

@@ -12,7 +12,10 @@ import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.utils.*
+import org.jetbrains.kotlin.fir.declarations.utils.delegateFields
+import org.jetbrains.kotlin.fir.declarations.utils.isData
+import org.jetbrains.kotlin.fir.declarations.utils.isExpect
+import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeRawScopeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -115,10 +118,6 @@ data class ConeSubstitutionScopeKey(
     val derivedClassLookupTag: ConeClassLikeLookupTag?
 ) : ScopeSessionKey<FirClass, FirClassSubstitutionScope>()
 
-data class AnySynthesizedScopeKey(
-    val lookupTag: ConeClassLikeLookupTag
-) : ScopeSessionKey<ConeClassLikeLookupTag, FirClassAnySynthesizedMemberScope>()
-
 fun FirClass.unsubstitutedScope(
     useSiteSession: FirSession,
     scopeSession: ScopeSession,

compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/FirOverrideService.kt

@@ -19,23 +19,8 @@ import org.jetbrains.kotlin.fir.types.ConeFlexibleType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.typeContext
 import org.jetbrains.kotlin.types.AbstractTypeChecker
-import java.util.*
 
 class FirOverrideService(val session: FirSession) : FirSessionComponent {
-    fun <D : FirCallableSymbol<*>> createOverridableGroups(
-        members: Collection<MemberWithBaseScope<D>>,
-        overrideChecker: FirOverrideChecker
-    ): List<List<MemberWithBaseScope<D>>> {
-        if (members.size <= 1) return listOf(members.toList())
-        val queue = LinkedList(members)
-        val result = mutableListOf<List<MemberWithBaseScope<D>>>()
-        while (queue.isNotEmpty()) {
-            val nextHandle = queue.first()
-            val overridableGroup = extractBothWaysOverridable(nextHandle, queue, overrideChecker)
-            result += overridableGroup
-        }
-        return result
-    }
 
     fun <D : FirCallableSymbol<*>> extractBothWaysOverridable(
         overrider: MemberWithBaseScope<D>,

compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeNullabilityChecker.kt

@@ -1,19 +0,0 @@
-/*
- * Copyright 2010-2021 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.fir.types
-
-import org.jetbrains.kotlin.types.AbstractNullabilityChecker
-import org.jetbrains.kotlin.types.TypeCheckerState
-
-object ConeNullabilityChecker {
-    fun isSubtypeOfAny(context: ConeTypeContext, type: ConeKotlinType): Boolean {
-        val actualType = with(context) { type.lowerBoundIfFlexible() }
-        return with(AbstractNullabilityChecker) {
-            context.newTypeCheckerState(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
-                .hasNotNullSupertype(actualType, TypeCheckerState.SupertypesPolicy.LowerIfFlexible)
-        }
-    }
-}

compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FunctionalTypeUtils.kt

@@ -104,17 +104,6 @@ fun ConeKotlinType.customFunctionTypeToSimpleFunctionType(session: FirSession):
     return createFunctionTypeWithNewKind(session, newKind)
 }
 
-/*
- * KFunction -> Function
- * KSuspendFunction -> SuspendFunction
- * K[Custom]Function -> [Custom]Function
- */
-fun ConeKotlinType.reflectFunctionTypeToNonReflectFunctionType(session: FirSession): ConeClassLikeType {
-    val kind = functionTypeKind(session)
-    require(kind != null && kind.isReflectType)
-    return createFunctionTypeWithNewKind(session, kind.nonReflectKind())
-}
-
 private fun ConeKotlinType.createFunctionTypeWithNewKind(session: FirSession, kind: FunctionTypeKind): ConeClassLikeType {
     val expandedType = fullyExpandedType(session)
     val functionTypeId = ClassId(kind.packageFqName, kind.numberedClassName(expandedType.typeArguments.size - 1))

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/AbstractLightTreeRawFirBuilder.kt

@@ -139,16 +139,6 @@ abstract class AbstractLightTreeRawFirBuilder(
         return tree.getParent(this)
     }
 
-    fun LighterASTNode.getParents(): Sequence<LighterASTNode> {
-        var node = this
-        return sequence {
-            while (true) {
-                yield(node)
-                node = node.getParent() ?: break
-            }
-        }
-    }
-
     fun LighterASTNode?.getChildNodesByType(type: IElementType): List<LighterASTNode> {
         return this?.forEachChildrenReturnList { node, container ->
             when (node.tokenType) {

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/ClassWrapper.kt

@@ -25,9 +25,6 @@ class ClassWrapper(
     val delegatedSuperTypeRef: FirTypeRef,
     val delegatedSuperCalls: List<DelegatedConstructorWrapper>,
 ) {
-    fun isObjectLiteral(): Boolean {
-        return className == SpecialNames.NO_NAME_PROVIDED && isObject()
-    }
 
     fun isEnumEntry(): Boolean {
         return classKind == ClassKind.ENUM_ENTRY

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/PsiRawFirBuilder.kt

@@ -82,10 +82,6 @@ open class PsiRawFirBuilder(
         return Visitor().visitAnnotationEntry(annotation, null) as FirAnnotationCall
     }
 
-    fun buildTypeReference(reference: KtTypeReference): FirTypeRef {
-        return reference.accept(Visitor(), null) as FirTypeRef
-    }
-
     override fun PsiElement.toFirSourceElement(kind: KtFakeSourceElementKind?): KtPsiSourceElement {
         val actualKind = kind ?: this@PsiRawFirBuilder.context.forcedElementSourceKind ?: KtRealSourceElementKind
         return this.toKtPsiSourceElement(actualKind)

compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/Context.kt

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.PrivateForInline
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.builder.buildOuterClassTypeParameterRef
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.name.ClassId
@@ -49,7 +48,6 @@ class Context<T> {
     var forcedElementSourceKind: KtSourceElementKind? = null
     val dispatchReceiverTypesStack = mutableListOf<ConeClassLikeType>()
     var containerIsExpect: Boolean = false
-    var containingFileSymbol: FirFileSymbol? = null
 
     fun pushFirTypeParameters(isInnerOrLocal: Boolean, parameters: List<FirTypeParameterRef>) {
         capturedTypeParameters.add(StatusFirTypeParameterSymbolList(isInnerOrLocal, parameters.map { it.symbol }))

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt

@@ -160,12 +160,6 @@ fun ControlFlowGraphBuilder.createConstExpressionNode(fir: FirConstExpression<*>
 fun ControlFlowGraphBuilder.createThrowExceptionNode(fir: FirThrowExpression): ThrowExceptionNode =
     ThrowExceptionNode(currentGraph, fir, levelCounter)
 
-fun ControlFlowGraphBuilder.createFinallyProxyExitNode(fir: FirTryExpression): FinallyProxyExitNode =
-    FinallyProxyExitNode(currentGraph, fir, levelCounter)
-
-fun ControlFlowGraphBuilder.createFinallyProxyEnterNode(fir: FirTryExpression): FinallyProxyEnterNode =
-    FinallyProxyEnterNode(currentGraph, fir, levelCounter)
-
 fun ControlFlowGraphBuilder.createFinallyBlockExitNode(fir: FirTryExpression): FinallyBlockExitNode =
     FinallyBlockExitNode(currentGraph, fir, levelCounter)
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt

@@ -90,9 +90,6 @@ class BodyResolveContext(
 
     var containingClassDeclarations: ArrayDeque<FirRegularClass> = ArrayDeque()
 
-    val topClassDeclaration: FirRegularClass?
-        get() = containingClassDeclarations.lastOrNull()
-
     @OptIn(PrivateForInline::class)
     inline fun <T> withTowerDataContexts(newContexts: FirRegularTowerDataContexts, f: () -> T): T {
         val old = regularTowerDataContexts

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt

@@ -522,18 +522,7 @@ class FinallyBlockExitNode(owner: ControlFlowGraph, override val fir: FirTryExpr
         return visitor.visitFinallyBlockExitNode(this, data)
     }
 }
-class FinallyProxyEnterNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode<FirTryExpression>(owner, level),
+
-    EnterNodeMarker {
-    override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
-        return visitor.visitFinallyProxyEnterNode(this, data)
-    }
-}
-class FinallyProxyExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode<FirTryExpression>(owner, level),
-    ExitNodeMarker {
-    override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
-        return visitor.visitFinallyProxyExitNode(this, data)
-    }
-}
 class TryExpressionExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode<FirTryExpression>(owner, level),
     ExitNodeMarker {
     override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNodeRenderer.kt

@@ -5,7 +5,10 @@
 
 package org.jetbrains.kotlin.fir.resolve.dfa.cfg
 
-import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
+import org.jetbrains.kotlin.fir.expressions.FirLoop
+import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
+import org.jetbrains.kotlin.fir.expressions.calleeReference
 import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.renderer.FirCallNoArgumentsRenderer
@@ -66,8 +69,6 @@ fun CFGNode<*>.render(): String =
                 is CatchClauseExitNode -> "Catch exit"
                 is FinallyBlockEnterNode -> "Enter finally"
                 is FinallyBlockExitNode -> "Exit finally"
-                is FinallyProxyEnterNode -> TODO()
-                is FinallyProxyExitNode -> TODO()
                 is TryExpressionExitNode -> "Try expression exit"
 
                 is BinaryAndEnterNode -> "Enter &&"

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphVisitor.kt

@@ -231,14 +231,6 @@ abstract class ControlFlowGraphVisitor<out R, in D> {
         return visitNode(node, data)
     }
 
-    open fun visitFinallyProxyEnterNode(node: FinallyProxyEnterNode, data: D): R {
-        return visitNode(node, data)
-    }
-
-    open fun visitFinallyProxyExitNode(node: FinallyProxyExitNode, data: D): R {
-        return visitNode(node, data)
-    }
-
     open fun visitTryExpressionExitNode(node: TryExpressionExitNode, data: D): R {
         return visitNode(node, data)
     }

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphVisitorVoid.kt

@@ -161,14 +161,6 @@ abstract class ControlFlowGraphVisitorVoid : ControlFlowGraphVisitor<Unit, Nothi
         visitNode(node)
     }
 
-    open fun visitFinallyProxyEnterNode(node: FinallyProxyEnterNode) {
-        visitNode(node)
-    }
-
-    open fun visitFinallyProxyExitNode(node: FinallyProxyExitNode) {
-        visitNode(node)
-    }
-
     open fun visitTryExpressionExitNode(node: TryExpressionExitNode) {
         visitNode(node)
     }
@@ -442,14 +434,6 @@ abstract class ControlFlowGraphVisitorVoid : ControlFlowGraphVisitor<Unit, Nothi
         visitFinallyBlockExitNode(node)
     }
 
-    final override fun visitFinallyProxyEnterNode(node: FinallyProxyEnterNode, data: Nothing?) {
-        visitFinallyProxyEnterNode(node)
-    }
-
-    final override fun visitFinallyProxyExitNode(node: FinallyProxyExitNode, data: Nothing?) {
-        visitFinallyProxyExitNode(node)
-    }
-
     final override fun visitTryExpressionExitNode(node: TryExpressionExitNode, data: Nothing?) {
         visitTryExpressionExitNode(node)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt

@@ -24,9 +24,6 @@ inline val FirCallableSymbol<*>.isFinal: Boolean
 inline val FirCallableSymbol<*>.visibility: Visibility get() = resolvedStatus.visibility
 inline val FirCallableSymbol<*>.effectiveVisibility: EffectiveVisibility get() = resolvedStatus.effectiveVisibility
 
-inline val FirCallableSymbol<*>.allowsToHaveFakeOverride: Boolean
-    get() = !Visibilities.isPrivate(visibility) && visibility != Visibilities.InvisibleFake
-
 inline val FirCallableSymbol<*>.isActual: Boolean get() = rawStatus.isActual
 inline val FirCallableSymbol<*>.isExpect: Boolean get() = rawStatus.isExpect
 inline val FirCallableSymbol<*>.isInner: Boolean get() = rawStatus.isInner
@@ -48,7 +45,6 @@ inline val FirCallableSymbol<*>.isFun: Boolean get() = rawStatus.isFun
 
 inline val FirClassLikeSymbol<*>.modality: Modality? get() = resolvedStatus.modality
 inline val FirClassLikeSymbol<*>.isAbstract: Boolean get() = resolvedStatus.modality == Modality.ABSTRACT
-inline val FirClassLikeSymbol<*>.isOpen: Boolean get() = resolvedStatus.modality == Modality.OPEN
 inline val FirClassLikeSymbol<*>.isFinal: Boolean
     get() {
         // member with unspecified modality is final
@@ -72,9 +68,6 @@ inline val FirClassLikeSymbol<*>.isCompanion: Boolean get() = rawStatus.isCompan
 inline val FirClassLikeSymbol<*>.isData: Boolean get() = rawStatus.isData
 inline val FirClassLikeSymbol<*>.isSealed: Boolean get() = resolvedStatus.modality == Modality.SEALED
 
-inline val FirRegularClassSymbol.canHaveAbstractDeclaration: Boolean
-    get() = isAbstract || isSealed || isEnumClass
-
 // ---------------------- common classes ----------------------
 
 inline val FirClassLikeSymbol<*>.isLocal: Boolean get() = classId.isLocal

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/declarationAttributes.kt

@@ -69,10 +69,6 @@ fun FirProperty.getExplicitBackingField(): FirBackingField? {
     }
 }
 
-fun FirPropertySymbol.getExplicitBackingField(): FirBackingField? {
-    return fir.getExplicitBackingField()
-}
-
 val FirProperty.canNarrowDownGetterType: Boolean
     get() {
         val backingFieldHasDifferentType = backingField != null && backingField?.returnTypeRef?.coneType != returnTypeRef.coneType

compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformerUtil.kt

@@ -47,12 +47,4 @@ inline fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirT
             iterator.set(result)
         }
     }
-}
+}
-
-fun <R, D> List<FirElement>.acceptAllElements(visitor: FirVisitor<R, D>, data: D) {
-    forEach { it.accept(visitor, data) }
-}
-
-fun List<FirElement>.acceptAllElements(visitor: FirVisitorVoid) {
-    forEach { it.accept(visitor) }
-}

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt

@@ -6,7 +6,10 @@
 package org.jetbrains.kotlin.fir.tree.generator
 
 import org.jetbrains.kotlin.fir.tree.generator.context.AbstractBuilderConfigurator
-import org.jetbrains.kotlin.fir.tree.generator.model.*
+import org.jetbrains.kotlin.fir.tree.generator.model.Element
+import org.jetbrains.kotlin.fir.tree.generator.model.Field
+import org.jetbrains.kotlin.fir.tree.generator.model.Implementation
+import org.jetbrains.kotlin.fir.tree.generator.model.LeafBuilder
 import org.jetbrains.kotlin.fir.tree.generator.printer.invisibleField
 import org.jetbrains.kotlin.fir.tree.generator.util.traverseParents
 
@@ -509,18 +512,4 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
         }
     }
 
-    private fun configureFieldInAllIntermediateBuilders(
-        field: String,
-        builderPredicate: ((IntermediateBuilder) -> Boolean)? = null,
-        fieldPredicate: ((Field) -> Boolean)? = null,
-        init: IntermediateBuilderConfigurationContext.(field: String) -> Unit
-    ) {
-        for (builder in FirTreeBuilder.intermediateBuilders) {
-            if (builderPredicate != null && !builderPredicate(builder)) continue
-            if (!builder.allFields.any { it.name == field }) continue
-            if (fieldPredicate != null && !fieldPredicate(builder[field])) continue
-            IntermediateBuilderConfigurationContext(builder).init(field)
-        }
-    }
-
 }