<idea-plugin>
  <extensionPoints>
    <extensionPoint
        qualifiedName="org.jetbrains.kotlin.kaResolveExtensionProvider"
        interface="org.jetbrains.kotlin.analysis.api.resolve.extensions.KaResolveExtensionProvider"
        area="IDEA_PROJECT"
        dynamic="true"
    />
  </extensionPoints>

  <extensions defaultExtensionNs="com.intellij">
    <projectService serviceImplementation="org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade"/>

        )

        assertThat(
            projectSchema.extension("generic").type,
            equalTo(inaccessible(genericType, nonPublic(PrivateComponentType::class.qualifiedName!!)))
        )
    }

    @Test
    fun `parameterized public type with non existing component type is represented as Inaccessible because of NonAvailable component type`() {

        ChildFirstClassLoader(getSystemClassLoader(), classPathWith(DeepThought::class.java)).use { loader ->

            val `class` = loader.loadClass(DeepThought::class.qualifiedName)

            val targetScope = mock<AbstractClassLoaderScope> {
                on { localClassLoader } doReturn loader
                on { exportClassLoader } doReturn loader.parent

    @Test
    fun `handles the hidden properties correctly`() {
        val aType = schema.dataClassesByFqName.getValue(DefaultFqName.parse(HasHiddenProperty::class.qualifiedName!!))
        assertTrue { aType.properties.single { it.name == "y" }.isHiddenInDsl }

        val result = schema.resolve(
            """
            x = 1
            y = 2
            """.trimIndent()

        Boolean::class -> DataTypeInternal.DefaultBooleanDataType.ref
        Long::class -> DataTypeInternal.DefaultLongDataType.ref
        is KClass<*> -> DataTypeRefInternal.DefaultName(DefaultFqName.parse(checkNotNull(qualifiedName)))
        else -> error("unexpected type")
    }


internal
fun checkInScope(
    type: KType,
    typeScope: DataSchemaBuilder.PreIndex
) {
    if (type.classifier?.isInScope(typeScope) != true) {

    override val analysisSession: KaFirSession,
) : KaSymbolProviderByJavaPsi(), KaFirSessionComponent {
    override fun getNamedClassSymbol(psiClass: PsiClass): KaNamedClassOrObjectSymbol? {
        if (psiClass.qualifiedName == null) return null
        if (psiClass is PsiTypeParameter) return null
        if (psiClass is KtLightClassMarker) return null
        if (psiClass.isKotlinCompiledClass()) return null

    when {
        key.startsWith("${ClassToKClass::class.qualifiedName}.") -> when {
            key.contains("Class(") -> listOf("type")
            key.contains("Classes(") -> listOf("types")
            else -> null
        }

        key.startsWith("${GroovyNamedArguments::class.qualifiedName}.") -> when {
            key.contains("Map(") -> listOf("args")

            get() = stack.peek()!!
    }

    visitor.visit(classLoader)
    return classLoaders
}


private
fun idOf(classLoader: ClassLoader): String =

            add("org.jetbrains.kotlin.analysis.api.fir.KaFirSession")
            convertersMap.values.flatMapTo(this) { it.importsToAdd }
            convertersMap.keys.mapNotNullTo(this) { it.qualifiedName }
        }
        printImports(imports)
    }

    private fun SmartPrinter.generateDispatchingConverter(convertersMap: Map<KClass<*>, HLParameterConversion>) {

    versionCatalogs: List<VersionCatalogAccessor>,
    format: AccessorFormat
) {
    appendReproducibleNewLine(
        """
        import ${ScriptHandlerScopeInternal::class.qualifiedName}
        import ${PluginDependenciesSpecScopeInternal::class.qualifiedName}
        """.trimIndent()
    )

    versionCatalogs.flatMap {