final class MainKt$test$1 {
    // source: 'main.kt'
    enclosing method MainKt.test()I
    public final static field INSTANCE: MainKt$test$1
    inner (anonymous) class MainKt$test$1
    static method <clinit>(): void
    method <init>(): void
    public synthetic bridge method invoke(): java.lang.Object
    public final method invoke(): void
}

public final class MainKt {
    // source: 'main.kt'
    inner (anonymous) class MainKt$test$1

import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.SpecialNames

internal class FirJavaDeclaredMembersOnlyScope(
    private val delegate: FirContainingNamesAwareScope,
    private val owner: FirJavaClass,
) : FirCallableFilteringScope(delegate) {
    init {
        // The `isDeclared` check is based on class IDs. Local classes don't have proper class IDs, but because this scope is used to

annotation class Anno(val value: KClass<*>)

@Anno(IntArray::class)

@Target(
    AnnotationTarget.CLASS,
    AnnotationTarget.PROPERTY,
    AnnotationTarget.CONSTRUCTOR,
    AnnotationTarget.FUNCTION,
    AnnotationTarget.TYPEALIAS
)
@RequiresOptIn("Internal Analysis API component which should not be used outside the Analysis API implementation modules as it does not have any compatibility guarantees")
public annotation class KaAnalysisApiInternals

}

/**
 * An implicit receiver. For example
 * ```
 * class A {
 *   val i: Int = 1
 *   fun test() {
 *     i // implicit receiver bound to class `A`
 *   }
 * }
 *
 * fun String.test() {
 *   length // implicit receiver bound to the `KaReceiverParameterSymbol` of type `String` declared by `test`.
 * }
 * ```
 */
public class KaImplicitReceiverValue(
    symbol: KaSymbol,
    type: KaType,

    public abstract val returnType: KaType
}

public typealias KtFunctionalType = KaFunctionalType

public abstract class KaUsualClassType : KaNonErrorClassType()

public typealias KtUsualClassType = KaUsualClassType

public abstract class KaClassErrorType : KaErrorType {
    public abstract val qualifiers: List<KaClassTypeQualifier>

// IGNORE_FE10
// KT-64503

// MODULE: lib
// MODULE_KIND: LibraryBinary
// FILE: TestExposeTypeLib.kt
abstract class TestExposeTypeLib {
    protected abstract fun returnProtectedClass(): ProtectedClass?
    protected class ProtectedClass
}

// MODULE: main(lib)
// FILE: usage.kt
class Usage : TestExposeTypeLib() {
    override fun returnProtectedClass(): ProtectedClass? = null

    when (signature) {
        is KaFunctionLikeSignature<*> -> append(KaFunctionLikeSignature::class.simpleName)
        is KaVariableLikeSignature<*> -> append(KaVariableLikeSignature::class.simpleName)
    }

    val memberProperties = listOfNotNull(
        KaVariableLikeSignature<*>::name.takeIf { signature is KaVariableLikeSignature<*> },

 */
public abstract class KotlinPackageProviderMerger : KotlinComposableProviderMerger<KotlinPackageProvider>, KotlinPlatformComponent {
    public companion object {
        public fun getInstance(project: Project): KotlinPackageProviderMerger = project.getService(KotlinPackageProviderMerger::class.java)
    }
}

                    }

                    testServices.assertions.assertNotNull(psiType)
                    val ktType = psiType!!.asKaType(useSitePosition ?: psiDeclaration)!!
                    appendLine("${PsiType::class.simpleName}: ${AnalysisApiPsiTypeProviderTestUtils.render(psiType)}")