import java.io.File
import kotlin.reflect.KClass
import kotlin.reflect.full.createType

private const val CONVERT_ARGUMENT = "convertArgument"

object ArgumentsConverterGenerator {
    fun render(file: File, packageName: String) {
        val convertArgumentFunctionCallConversion = HLFunctionCallConversion(
            "$CONVERT_ARGUMENT({0}, firSymbolBuilder)",
            callType = Any::class.createType(nullable = true)
        )

fun <T : Any> Request.Builder.commonTag(
  type: KClass<T>,
  tag: T?,
) = apply {
  if (tag == null) {
    if (tags.isNotEmpty()) {
      (tags as MutableMap).remove(type)
    }
  } else {
    val mutableTags: MutableMap<KClass<*>, Any> =
      when {
        tags.isEmpty() -> mutableMapOf<KClass<*>, Any>().also { tags = it }
        else -> tags as MutableMap<KClass<*>, Any>
      }
    mutableTags[type] = tag

            } + nullableSuffix
        }
    }
    print(typeConversion(type))
}

val KType.simpleName: String
    get() = (classifier as KClass<*>).simpleName!!

val KType.qualifiedName: String

        Variance::class,
        FqName::class,
        ClassId::class,
        FirModuleData::class,
        ExpectActualCompatibility::class,
        ExpectActualCompatibility.MismatchOrIncompatible::class,
        ExpectActualAnnotationsIncompatibilityType::class,
        DeprecationInfo::class,
        ApiVersion::class,
        CallableId::class,
        ClassKind::class,
        FunctionTypeKind::class,

import kotlin.reflect.KClass
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.http2.Http2

object OkHttpDebugLogging {
  // Keep references to loggers to prevent their configuration from being GC'd.
  private val configuredLoggers = CopyOnWriteArraySet<Logger>()

  fun enableHttp2() = enable(Http2::class)

  fun enableTaskRunner() = enable(TaskRunner::class)

  fun logHandler() =

import java.util.concurrent.ConcurrentMap
import kotlin.reflect.KClass

/**
 * [KtFirAnalysisSessionProvider] keeps [KtFirAnalysisSession]s in a cache, which are actively invalidated with their associated underlying
 * [LLFirSession][org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession]s.
 */
internal class KtFirAnalysisSessionProvider(project: Project) : KtAnalysisSessionProvider(project) {

<component name="ProjectDictionaryState">
  <dictionary name="bashor">
    <words>
      <w>binaryen</w>
      <w>ctor</w>
      <w>inlining</w>
      <w>interner</w>
      <w>intrinsicify</w>
      <w>kclass</w>
      <w>lookups</w>
      <w>minification</w>
      <w>minifier</w>
      <w>minify</w>
      <w>unescape</w>
    </words>
  </dictionary>

import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtFile
import kotlin.reflect.KClass

internal class KtFe10DiagnosticProvider(
    override val analysisSession: KtFe10AnalysisSession
) : KtDiagnosticProvider(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken

//
// Rules
// 1. an extension should either require no type parameters, a single reifeid type parameter, at call site
// 2. all type parameters must all be reifeid or values (TypeOf, KClass or Class)
// 3. when overloading, prefer TypeOf over Class
// 4. in case the policy forbids your overloads, discuss
private
fun kotlinExtensionFunctionsFor(type: ApiType, sinceSupplier: (String) -> String?): Sequence<KotlinExtensionFunction> =

  @JvmName("reifiedTag")
  inline fun <reified T : Any> tag(): T? = tag(T::class)

  /** Returns the tag attached with [type] as a key, or null if no tag is attached with that key. */
  fun <T : Any> tag(type: KClass<T>): T? = type.java.cast(tags[type])

  /**
   * Returns the tag attached with `Object.class` as a key, or null if no tag is attached with
   * that key.
   *