} else { //member
                val classId = import.resolvedClassId ?: error("Class id should not be null as relativeClassName is not null")
                firScope.getStaticsScope(classId)?.getCallableNames().orEmpty()
            }
        }
    }

    override fun getPackageSymbols(nameFilter: KtScopeNameFilter): Sequence<KtPackageSymbol> = withValidityAssertion {
        emptySequence()
    }

        }

        return firSymbol.expectForActual?.get(ExpectActualMatchingCompatibility.MatchedSuccessfully)
            ?.map { analysisSession.firSymbolBuilder.buildSymbol(it) as KtDeclarationSymbol }.orEmpty()
    }

        val memberDescriptor = (getSymbolDescriptor(actual) as? MemberDescriptor)?.takeIf { it.isActual } ?: return emptyList()

        return ExpectedActualResolver.findExpectedForActual(memberDescriptor).orEmpty().asSequence()
            .filter { it.key.isCompatibleOrWeaklyIncompatible }
            .flatMap { it.value }
            .map { it.toKtSymbol(analysisContext) as KtDeclarationSymbol }
            .toList()
    }

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

  val url = url ?: throw IOException("No url provided")

  request.url(url)

  data?.let {
    request.method(requestMethod, it.toRequestBody(mediaType()))
  }

  for (header in headers.orEmpty()) {
    val parts = header.split(':', limit = 2)
    if (!isSpecialHeader(parts[0])) {
      request.header(parts[0], parts[1])
    }
  }
  referer?.let {
    request.header("Referer", it)
  }

                psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisContext) }
            } else {
                // There might be implicit 'it'
                descriptor?.valueParameters.orEmpty().map { KtFe10DescValueParameterSymbol(it, analysisContext) }
            }
        }

    override val hasStableParameterNames: Boolean
        get() = withValidityAssertion { true }

      "$prefix/samples/guide/src/main/java/okhttp3/recipes",
      "$prefix/samples/guide/src/main/java/okhttp3/recipes/kt",
    ).map { File(it) }

  return directories.flatMap {
    it.listFiles().orEmpty().filter { f -> f.isFile }.toList()
  }
}

internal class MainTestProvider : SimpleProvider() {
  override fun arguments(): List<Any> {
    val mainFiles = mainFiles()
    return mainFiles.map {

        } else {
            firResolveSession.getSessionFor(positionModule)
        }

        val effectiveContainers = collectUseSiteContainers(position, firResolveSession).orEmpty()

        return effectiveSession.visibilityChecker.isVisible(
            candidateDeclaration,
            effectiveSession,
            useSiteFile.firSymbol.fir,
            effectiveContainers,

                        )
                    },
                    sourcePsi = null,
                    token
                ),
                token
            )
        )
    }.orEmpty()

    return toKtAnnotationApplication(builder, index, arguments)
}

private fun FirAnnotation.asKtAnnotationApplicationForTargetAnnotation(
    builder: KtSymbolByFirBuilder,
    index: Int,

        descriptor.getUserData(ContractProviderKey)?.getContractDescription()?.effects
            ?.map { it.effectDeclarationToAnalysisApi(analysisContext) }
            .orEmpty()
    }

    override val symbolKind: KtSymbolKind
        get() = withValidityAssertion {
            if (descriptor.isDynamic()) {
                return@withValidityAssertion KtSymbolKind.CLASS_MEMBER
            }