val elementToAnalyze = positionInFakeFile.containingNonLocalDeclaration() ?: originalFile
        val bindingContext = analysisContext.analyze(elementToAnalyze)

        val scopeKind = KtScopeKind.LocalScope(0) // TODO
        val lexicalScope = positionInFakeFile.getResolutionScope(bindingContext)
        if (lexicalScope != null) {

    ) {
      val settings = response.settings
      stream.connection.setSettings(settings)

      if (response.socketPolicy === NoResponse) {
        return
      }

      val bodyDelayNanos = response.bodyDelayNanos
      val trailers = response.trailers
      val body = response.body
      val streamHandler = response.streamHandler
      val outFinished = (
        body == null &&

internal class KtFe10AnnotationsList private constructor(
    private val fe10Annotations: Annotations,
    private val annotationsToIgnore: Set<ClassId>,
    private val analysisContext: Fe10AnalysisContext
) : KtAnnotationsList() {
    override val token: KtLifetimeToken
        get() = analysisContext.token

    override val annotations: List<KtAnnotationApplicationWithArgumentsInfo>
        get() = withValidityAssertion {

    override val psi: PsiElement?
        get() = withValidityAssertion { null }

    override val annotationsList: KtAnnotationsList
        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }

    override val name: Name
        get() = withValidityAssertion { Name.identifier("args") }

    override val hasDefaultValue: Boolean
        get() = withValidityAssertion { false }

    override val isVararg: Boolean

        .build()
    val request = Request.Builder().url(server.url("/")).build()
    val response1 = client.newCall(request).execute()
    val source = response1.body.source()
    assertThat(source.readUtf8()).isEqualTo("ABC")

    // OpenJDK 6 fails on this line, complaining that the connection isn't open yet
    val cipherSuite = response1.handshake!!.cipherSuite
    val localCerts = response1.handshake!!.localCertificates

func (j *Array[T]) Set(val []T) {
	j.val = val
}

// Recycle the underlying value.
func (j *Array[T]) Recycle() {
	if j.val != nil {
		j.p.putA(j.val)
		j.val = nil
	}
}

// MarshalMsg implements msgp.Marshaler
func (j *Array[T]) MarshalMsg(b []byte) (o []byte, err error) {
	if j.val == nil {
		return msgp.AppendNil(b), nil
	}
	if uint64(len(j.val)) > math.MaxUint32 {

import org.jetbrains.kotlin.resolve.BindingContext

internal class KtFe10PsiLocalVariableSymbol(
    override val psi: KtVariableDeclaration,
    override val analysisContext: Fe10AnalysisContext
) : KtLocalVariableSymbol(), KtFe10PsiSymbol<KtVariableDeclaration, VariableDescriptor> {
    override val descriptor: VariableDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)

import org.jetbrains.kotlin.name.FqName

internal class KtFe10PackageSymbol(
    private val packageName: FqName,
    override val analysisContext: Fe10AnalysisContext
) : KtPackageSymbol(), KtFe10Symbol {
    override val fqName: FqName
        get() = withValidityAssertion { packageName }

    override val psi: PsiElement? by cached {
        val project = analysisContext.resolveSession.project

internal class KtFe10PsiPropertyGetterSymbol(
    override val psi: KtPropertyAccessor,
    override val analysisContext: Fe10AnalysisContext
) : KtPropertyGetterSymbol(), KtFe10PsiSymbol<KtPropertyAccessor, PropertyGetterDescriptor> {
    override val descriptor: PropertyGetterDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)

    }

    private fun ConeKotlinType.toTargetSymbol(session: FirSession, symbolBuilder: KtSymbolByFirBuilder): KtSymbol? {
        val type = this as? ConeLookupTagBasedType
        val resolvedSymbol = type?.lookupTag?.toSymbol(session) as? FirBasedSymbol<*>

        val symbol = resolvedSymbol ?: run {
            val diagnostic = (this as? ConeErrorType)?.diagnostic
            (diagnostic as? ConeUnmatchedTypeArgumentsError)?.symbol
        }