return symbolImplementationPackageNames.none { qualifiedName.startsWith("$it.") }
        }

        val valueClass = value::class
        val allClasses = listOf(valueClass) + valueClass.allSuperclasses

        val matchingClasses = allClasses.filter { it.isFrontendIndependent() }
        val matchingClassSet = matchingClasses.toSet()

    }

    override fun getDirectSuperTypes(type: KaType, shouldApproximate: Boolean): List<KaType> {
        require(type is KaFe10Type)
        return TypeUtils.getImmediateSupertypes(type.fe10Type).map { it.toKtType(analysisContext) }
    }

    override fun getAllSuperTypes(type: KaType, shouldApproximate: Boolean): List<KaType> {
        require(type is KaFe10Type)

            projectDisposable,
            KotlinCoreApplicationEnvironmentMode.fromUnitTestModeFlag(unitTestMode),
            classLoader = classLoader
        )

    private val serviceRegistrars = listOf(FirStandaloneServiceRegistrar, StandaloneSessionServiceRegistrar)

    init {
        val application = kotlinCoreProjectEnvironment.environment.application

     *
     * ```
     * typealias MyString = String
     * typealias MyList<A> = List<A>
     *
     * val list: MyList<MyString> = listOf()
     * ```
     *
     * `MyList<MyString>` may be expanded to a type `List<String>` with an abbreviated type `MyList<String>`, where `String` also has the

                type
            }.withNullability(nullability, session.typeContext)
        }
    }

    override fun getAllSuperTypes(type: KaType, shouldApproximate: Boolean): List<KaType> {
        require(type is KaFirType)
        return listOf(type.coneType)
            .bfs { it.getDirectSuperTypes(shouldApproximate).iterator() }
            .drop(1)
            .mapTo(mutableListOf()) { it.asKtType() }
    }

    get() = systemProperty(PREDICTIVE_TEST_SELECTION_ENABLED)
        .map { it.toBoolean() }
        .orElse(
            buildBranch.zip(buildRunningOnCi) { branch, ci ->
                val protectedBranches = listOf("master", "release")
                ci && !protectedBranches.contains(branch)
                    && !branch.startsWith("pre-test/")
                    && !branch.startsWith("gh-readonly-queue/")
            }

}

internal fun KaSession.assertStableSymbolResult(
    testServices: TestServices,
    firstCandidates: List<KaCallCandidateInfo>,
    secondCandidates: List<KaCallCandidateInfo>,
) {
    val assertions = testServices.assertions
    assertions.assertEquals(firstCandidates.size, secondCandidates.size)

        psi: KtElement,
        getErrorCallInfo: FirDiagnosticHolder.(psiToResolve: KtElement) -> List<T>,
        getCallInfo: FirElement.(
            psiToResolve: KtElement,
            resolveCalleeExpressionOfFunctionCall: Boolean,
            resolveFragmentOfCall: Boolean,
        ) -> List<T>,
    ): List<T> {
        if (!canBeResolvedAsCall(psi)) return emptyList()

            jdkHome,
        )
    }

    private fun initialiseVirtualFileFinderServices(
        environment: KotlinCoreProjectEnvironment,
        modules: List<KtModule>,
        sourceFiles: List<PsiFileSystemItem>,
        languageVersionSettings: LanguageVersionSettings,
        jdkHome: Path?,
    ) {
        val project = environment.project

        is FirStatement -> with(analysisSession) { builtinTypes.unit }
        is FirTypeRef, is FirImport, is FirPackageDirective, is FirLabel, is FirTypeParameterRef -> null

        // `listOf<_>(1)` where `expression` is `_`
        is FirPlaceholderProjection -> null
        else -> null
    }

    /**