) {
    if (symbol.origin != KaSymbolOrigin.SOURCE) return
    val containingFileSymbol = symbol.getContainingFileSymbol()
    testServices.assertions.assertEquals(ktFileSymbol, containingFileSymbol) {
        "Invalid file for $symbol, expected $ktFileSymbol but $containingFileSymbol found"
    }
}

internal fun KaSession.checkContainingJvmClassName(
    ktFile: KtFile,
    ktClass: KtClassOrObject?,
    symbol: KaCallableSymbol,

}

public typealias KtLifetimeTokenFactory = KaLifetimeTokenFactory

@Suppress("NOTHING_TO_INLINE")
public inline fun KaLifetimeToken.assertIsValidAndAccessible() {
    if (!isValid()) {
        throw KaInvalidLifetimeOwnerAccessException("Access to invalid $this: ${getInvalidationReason()}")
    }
    if (!isAccessible()) {
        throw KaInaccessibleLifetimeOwnerAccessException("$this is inaccessible: ${getInaccessibilityReason()}")
    }

                } catch (e: ArithmeticException) {
                    KaConstantValue.KaErrorConstantValue(e.localizedMessage, sourcePsi)
                }
            }
            // For invalid code like the following,
            // ```
            // when {
            //   true, false -> {}
            // }
            // ```

                    } else {
                        testServices.assertions.assertEquals(expectedParentDeclarationSymbol, actualParentDeclarationSymbol) {
                            "Invalid parent declaration for $currentDeclarationSymbol, expected $expectedParentDeclarationSymbol but $actualParentDeclarationSymbol found"
                        }
                    }

            if (shouldSkipValidityCheck(session)) return@forEach

            testServices.assertions.assertFalse(isSessionValid(session)) {
                "The invalidated session `${session}` should have been marked invalid."
            }
        }
    }

    private fun checkUntouchedSessionValidity(
        sessions: Set<SESSION>,
        testServices: TestServices,
    ) {
        sessions.forEach { session ->

                    create(diagnostic as KtDiagnosticWithParameters4<Any?, Any?, Any?, Any?>)
                }
                else -> error("Invalid KtFirDiagnosticCreator ${creator::class.simpleName}")
            }
        }
    }

    @Suppress("RemoveExplicitTypeArguments") // See KT-52838

            is FirRegularClass -> declaration.collectForLocal()
            is FirTypeAlias -> listOf(declaration) // TODO: handle type aliases
            else -> errorWithAttachment("Invalid declaration ${declaration::class}") {
                withFirEntry("declaration", declaration)
            }
        }
    }

        KotlinLifetimeTokenProvider.getService(project).getLifetimeTokenFactory()
    }

    override fun beforeEnteringAnalysis(session: KtAnalysisSession, useSiteElement: KtElement) {
        // Catch issues with analysis on invalid PSI as early as possible.
        PsiUtilCore.ensureValid(useSiteElement)

        beforeEnteringAnalysis(session)
    }

    override fun beforeEnteringAnalysis(session: KtAnalysisSession, useSiteModule: KtModule) {

            origin is FirDeclarationOrigin.Synthetic.ForwardDeclaration -> KaSymbolOrigin.NATIVE_FORWARD_DECLARATION

            else -> errorWithAttachment("Invalid FirDeclarationOrigin ${origin::class.simpleName}") {
                withFirEntry("firToGetOrigin", this@ktSymbolOrigin)
            }
        }
    }

    FirDeclarationOrigin.ImportedFromObjectOrStatic -> {

                "enum_entry_initializer" -> EnumEntryInitializerData(extractCallableId(value))
                "sam_constructor" -> SamConstructorData(ClassId.fromString(value))
                else -> error("Invalid symbol kind, expected one of: $identifiers")
            }
        }
    }
}

private fun extractPackageFqName(data: String): FqName = FqName.fromSegments(data.split('.'))