.flatMap { sourceNamesFrom(it) }
            .mapNotNull { sourceName ->
                classBytesSupplierForSourceName(sourceName)?.let { sourceName to it }
            }

    private
    fun classBytesSupplierForSourceName(sourceName: String): ClassBytesSupplier? =
        classFilePathCandidatesFor(sourceName)
            .mapNotNull(::classBytesSupplierForFilePath)
            .firstOrNull()

    private

    override val typeParameters: List<KtTypeParameterSymbol>
        get() = withValidityAssertion {
            descriptor.typeParameters.mapNotNull {
                if (it.containingDeclaration != descriptor) return@mapNotNull null
                KtFe10DescTypeParameterSymbol(it, analysisContext)
            }
        }

        return scope
            .getContributedDescriptors(kindFilter = DescriptorKindFilter.ALL, nameFilter)
            .asSequence()
            .filter { nameFilter(it.name) }
            .mapNotNull { it.toKtSymbol(analysisContext) as? KtCallableSymbol }
    }

    override fun getCallableSymbols(names: Collection<Name>): Sequence<KtCallableSymbol> = withValidityAssertion {

    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
        return expression.resolveCall()?.calls.orEmpty().mapNotNull { call ->
            (call as? KtSimpleFunctionCall)
                ?.takeIf { it.isImplicitInvoke }
                ?.partiallyAppliedSymbol
                ?.symbol

        val inheritorClassIds = classSymbol.firSymbol.fir.getSealedClassInheritors(analysisSession.useSiteSession)

        return with(analysisSession) {
            inheritorClassIds.mapNotNull { getClassOrObjectSymbolByClassId(it) as? KtNamedClassOrObjectSymbol }
        }
    }

    override fun getEnumEntries(classSymbol: KtNamedClassOrObjectSymbol): List<KtEnumEntrySymbol> {

        }
        val descriptor = getSymbolDescriptor(callableSymbol) as? CallableMemberDescriptor ?: return emptyList()
        return getOverriddenDescriptors(descriptor, true).mapNotNull { it.toKtCallableSymbol(analysisContext) }.distinct()
    }

    override fun <T : KtSymbol> getDirectlyOverriddenSymbols(callableSymbol: T): List<KtCallableSymbol> {
        if (callableSymbol is KtValueParameterSymbol) {

        symbol.origin == KtSymbolOrigin.INTERSECTION_OVERRIDE && symbol is KtCallableSymbol -> symbol.getIntersectionOverriddenSymbols()
        else -> listOf(symbol)
    }
    return intersectionOverriddenSymbolsOrSingle.mapNotNull { it.findPsiForReferenceResolve() }
}

private fun KtSymbol.findPsiForReferenceResolve(): PsiElement? {
    require(this is KtFirSymbol<*>)
    return firSymbol.fir.findReferencePsi()

        require(reference is KtFe10Reference)
        val bindingContext = analysisContext.analyze(reference.element, Fe10AnalysisFacade.AnalysisMode.PARTIAL)
        return reference.getTargetDescriptors(bindingContext).mapNotNull { descriptor ->
            descriptor.toKtSymbol(analysisContext)
        }
    }

    override fun isImplicitReferenceToCompanion(reference: KtReference): Boolean {
        if (reference !is KtSimpleNameReference) {

    override val annotationsObject: Annotations by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
        Annotations.create(
            psi.annotationEntries.mapNotNull { entry ->
                bindingContext[BindingContext.ANNOTATION, entry]
            }
        )
    }

    override val analysisContext: Fe10AnalysisContext get() = analysisSession.analysisContext

  val testSelector = DiscoverySelectors.selectPackage("okhttp3")
  val testClasses =
    findTests(listOf(testSelector))
      .filter { it.isContainer }
      .mapNotNull { (it as? ClassBasedTestDescriptor)?.testClass?.name }
      .filterNot { it in avoidedTests }
      .sorted()
      .distinct()
  knownTestFile.writeText(testClasses.joinToString("\n"))