}

  override fun doExtensiveHealthChecks(): Boolean {
    return chain.request.method != "GET"
  }

  override fun isCanceled(): Boolean {
    return call.isCanceled()
  }

  override fun candidateConnection(): RealConnection? {
    return call.connection
  }

  override fun proxySelectStart(url: HttpUrl) {
    eventListener.proxySelectStart(call, url)
  }

  override fun proxySelectEnd(

    override suspend fun ReadContext.decode() =
        readLengthPrefixedShorts(this)
}


object IntArrayCodec : Codec<IntArray> {
    override suspend fun WriteContext.encode(value: IntArray) =
        writeLengthPrefixedInts(this, value)

    override suspend fun ReadContext.decode() =
        readLengthPrefixedInts(this)
}


object LongArrayCodec : Codec<LongArray> {

    }

    private
    fun loaderClassBytesIndexFor(loader: ClassLoader): ClassBytesIndex = { classFilePath ->
        loader.getResource(classFilePath)?.let {
            { loader.getResourceAsStream(classFilePath).use { it!!.readBytes() } }
        }
    }

    private
    fun openJarFile(file: File) =
        openJars.computeIfAbsent(file, ::JarFile)

    override fun close() {

    public abstract fun getTypeAliasSymbol(psi: KtTypeAlias): KaTypeAliasSymbol
    public abstract fun getEnumEntrySymbol(psi: KtEnumEntry): KaEnumEntrySymbol
    public abstract fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KaAnonymousFunctionSymbol
    public abstract fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KaAnonymousFunctionSymbol

) : MessageCollector {

    val errors = arrayListOf<ScriptCompilationError>()

    override fun hasErrors() = errors.isNotEmpty()

    override fun clear() = errors.clear()

    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {

        fun msg() =
            location?.run {
                path.let(pathTranslation).let { path ->

}

private fun convertArgument(argument: FirEnumEntrySymbol, firSymbolBuilder: KaSymbolByFirBuilder): Any? {
    return firSymbolBuilder.buildSymbol(argument)
}

private fun convertArgument(argument: FirRegularClassSymbol, firSymbolBuilder: KaSymbolByFirBuilder): Any? {
    return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument)
}

		return nil
	}

	fun := astutil.Unparen(call.Args[1])
	if lit, ok := fun.(*ast.FuncLit); ok { // function lit?
		return &asyncCall{region: lit, async: call, scope: lit, fun: fun}
	}

	if id := funcIdent(fun); id != nil {
		if lit := funcLitInScope(id); lit != nil { // function lit in variable?
			return &asyncCall{region: lit, async: call, scope: lit, fun: fun}
		}
	}

    override fun getPosition() = position
}


internal
data class DefaultEditorPosition(
    private val line: Int,
    private val column: Int = 0
) : EditorPosition, Serializable {

    override fun getLine() = line

    override fun getColumn() = column
}


internal
fun File.readLinesRange() =
    countLines().let { count ->
        if (count == 0L) 0..0L

  override fun callEnd(call: Call) {
    logWithTime("callEnd")

    delegate.callEnd(call)
  }

  override fun callFailed(
    call: Call,
    ioe: IOException,
  ) {
    logWithTime("callFailed: $ioe")

    delegate.callFailed(call, ioe)
  }

  override fun canceled(call: Call) {
    logWithTime("canceled")

    delegate.canceled(call)
  }

  override fun satisfactionFailure(

    delegate!!.invalidate()
  }

  override fun isValid(): Boolean {
    return delegate!!.isValid
  }

  override fun putValue(
    s: String,
    o: Any,
  ) {
    delegate!!.putValue(s, o)
  }

  override fun getValue(s: String): Any {
    return delegate!!.getValue(s)
  }

  override fun removeValue(s: String) {
    delegate!!.removeValue(s)
  }