require(analysisSession is KaFirSession)
        val classLikeSymbol = analysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbolByClassId(classId) ?: return null
        if (!expectedClass.isInstance(classLikeSymbol)) return null

        @Suppress("UNCHECKED_CAST")
        return classLikeSymbol as T
    }

    override fun pointsToTheSameSymbolAs(other: KaSymbolPointer<KaSymbol>): Boolean = other === this ||

                else -> {
                    error("Unexpected declaration to restore: ${psi::class}, text:\n ${psi.text}")
                }
            }
        }

        if (!expectedClass.isInstance(symbol)) return null

        @Suppress("UNCHECKED_CAST")
        return symbol as S
    }

    override fun pointsToTheSameSymbolAs(other: KaSymbolPointer<KaSymbol>): Boolean = this === other ||

public final class main/Main {
    // source: 'main.kt'
    public final static field INSTANCE: main.Main
    static method <clinit>(): void
    private method <init>(): void
    public final static method main(p0: java.lang.String[]): void

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

final class MainKt$ArticleScreenContent$1 {
    // source: 'main.kt'
    enclosing method MainKt.ArticleScreenContent$default(Ljava/lang/String;Lkotlin/jvm/functions/Function0;ILjava/lang/Object;)V
    public final static field INSTANCE: MainKt$ArticleScreenContent$1
    inner (anonymous) class MainKt$ArticleScreenContent$1
    static method <clinit>(): void
    method <init>(): void
    public synthetic bridge method invoke(): java.lang.Object

                    psi.isAnnotation() -> KaClassKind.ANNOTATION_CLASS
                    else -> KaClassKind.CLASS
                }
                else -> error("Unexpected class instance")
            }
        }

    override val superTypes: List<KaType>
        get() = withValidityAssertion {
            descriptor?.getSupertypesWithAny()?.map { it.toKtType(analysisContext) } ?: emptyList()

     *
     * @param receiverExpression a qualified expression receiver (e.g., `foo` in `foo?.bar()`, or in `foo.bar`).
     *
     * The function unwraps certain receiver expressions. For instance, for safe calls direct counterpart to a [KtSafeQualifiedExpression]
     * is (FirCheckedSafeCallSubject)[org.jetbrains.kotlin.fir.expressions.FirCheckedSafeCallSubject] which requires additional unwrapping

    override fun registerApplicationServices(application: MockApplication, testServices: TestServices) {
        FileTypeFileViewProviders.INSTANCE.addExplicitExtension(JavaClassFileType.INSTANCE, ClassFileViewProviderFactory())
        FileTypeFileViewProviders.INSTANCE.addExplicitExtension(
            KlibMetaFileType,
            FileViewProviderFactory { file, _, manager, _ ->

 */

package org.jetbrains.kotlin.analysis.api.lifetime

import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty

/**
 * Represents a value with validity assertions.
 *
 * To create an instance of [KaLifetimeOwnerField] use the [validityAsserted] function.
 *
 * @see KaLifetimeOwner
 * @see validityAsserted
 */
@JvmInline

import java.nio.file.Path
import java.nio.file.Paths

object LibraryUtils {
    /**
     * Get all [VirtualFile]s inside the given [jar] (of [Path])
     *
     * Note that, if [CoreJarFileSystem] is not given, a fresh instance will be used, which will create fresh instances of [VirtualFile],
     *   resulting in potential hash mismatch (e.g., if used in scope membership check).
     *