}

  override fun shutdown() {
    shutdown = true
  }

  override fun shutdownNow(): List<Runnable> {
    throw UnsupportedOperationException()
  }

  override fun isShutdown(): Boolean {
    return shutdown
  }

  override fun isTerminated(): Boolean {
    throw UnsupportedOperationException()
  }

  override fun awaitTermination(
    timeout: Long,

import org.jetbrains.kotlin.psi.KtProperty
import org.jetbrains.kotlin.resolve.BindingContext

internal class KtFe10PsiDefaultBackingFieldSymbol(
    private val propertyPsi: KtProperty,
    override val owningProperty: KtKotlinPropertySymbol,
    override val analysisContext: Fe10AnalysisContext
) : KtBackingFieldSymbol(), KtFe10Symbol {
    val descriptor: FieldDescriptor? by cached {

import org.jetbrains.kotlin.types.checker.NewCapturedType

internal class KtFe10NewCapturedType(
    override val fe10Type: NewCapturedType,
    override val analysisContext: Fe10AnalysisContext
) : KtCapturedType(), KtFe10Type {
    override fun asStringForDebugging(): String = withValidityAssertion { fe10Type.asStringForDebugging(analysisContext) }

    override val nullability: KtTypeNullability
        get() = withValidityAssertion { fe10Type.ktNullability }

internal class KtFe10ResolveExtensionInfoProvider(
    override val analysisSession: KtFe10AnalysisSession,
) : KtResolveExtensionInfoProvider(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

    override fun getResolveExtensionScopeWithTopLevelDeclarations(): KtScope {
        return KtEmptyScope(token)
    }

    override fun isResolveExtensionFile(file: VirtualFile): Boolean = false

      renameFaults.remove(file)
    }
  }

  @Throws(IOException::class)
  override fun atomicMove(
    source: Path,
    target: Path,
  ) {
    if (renameFaults.contains(source) || renameFaults.contains(target)) throw IOException("boom!")
    super.atomicMove(source, target)
  }

  @Throws(IOException::class)
  override fun delete(
    path: Path,
    mustExist: Boolean,
  ) {

        override fun visitElement(element: FirElement) {
            element.acceptChildren(this)
        }

        override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) = visitFunction(anonymousFunction)
        override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) = visitFunction(propertyAccessor)

import org.jetbrains.kotlin.analysis.api.fir.utils.isSubClassOf

internal class KtFirSymbolDeclarationOverridesProvider(
    override val analysisSession: KtFirAnalysisSession,
    override val token: KtLifetimeToken
) : KtSymbolDeclarationOverridesProviderBase(), KtFirAnalysisSessionComponent {
    override fun <T : KtSymbol> getAllOverriddenSymbols(
        callableSymbol: T,
    ): List<KtCallableSymbol> {

    override fun isTargetCallable(callable: FirCallableSymbol<*>): Boolean =
        callable.callableId.callableName != SpecialNames.INIT && callable.fir.isDeclared()

    override fun processDeclaredConstructors(processor: (FirConstructorSymbol) -> Unit) {
        delegate.processDeclaredConstructors(processor)
    }

    override fun getClassifierNames(): Set<Name> = delegate.getClassifierNames()

import org.jetbrains.kotlin.fir.declarations.getSealedClassInheritors

internal class KtFirInheritorsProvider(
    override val analysisSession: KtFirAnalysisSession,
    override val token: KtLifetimeToken,
) : KtInheritorsProvider(), KtFirAnalysisSessionComponent {
    override fun getInheritorsOfSealedClass(
        classSymbol: KtNamedClassOrObjectSymbol
    ): List<KtNamedClassOrObjectSymbol> {

internal class KtFe10JvmTypeMapper(
    override val analysisSession: KtFe10AnalysisSession
) : KtJvmTypeMapper(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

    private val typeMapper by lazy { KtFe10JvmTypeMapperContext(analysisContext.resolveSession) }

    override fun mapTypeToJvmType(type: KtType, mode: TypeMappingMode): Type {