public val symbolKind: KaSymbolKind
}

public typealias KtSymbolWithKind = KaSymbolWithKind

public enum class KaSymbolKind {
    TOP_LEVEL,
    CLASS_MEMBER,
    LOCAL,
    ACCESSOR,
    SAM_CONSTRUCTOR,
}

                ?: getTypeAliasByClassId(classId)
                ?: error("Class-like symbol is not found by '$classId'")

            val samConstructor = symbol.getSamConstructor() ?: error("SAM constructor is not found for symbol '$symbol'")
            return listOf(samConstructor)
        }
    }

    companion object {
        val identifiers = arrayOf(
            "package:",
            "callable:",

public abstract class KaSamConstructorSymbol : KaFunctionLikeSymbol(), KaNamedSymbol {
    final override val symbolKind: KaSymbolKind get() = withValidityAssertion { KaSymbolKind.SAM_CONSTRUCTOR }

    abstract override fun createPointer(): KaSymbolPointer<KaSamConstructorSymbol>
}

public typealias KtSamConstructorSymbol = KaSamConstructorSymbol

    is FirDeclarationOrigin.Java.Source -> KaSymbolOrigin.JAVA_SOURCE
    is FirDeclarationOrigin.Java.Library -> KaSymbolOrigin.JAVA_LIBRARY
    FirDeclarationOrigin.SamConstructor -> KaSymbolOrigin.SAM_CONSTRUCTOR
    FirDeclarationOrigin.Enhancement, FirDeclarationOrigin.RenamedForOverride -> javaOriginBasedOnSessionKind()
    FirDeclarationOrigin.IntersectionOverride -> KaSymbolOrigin.INTERSECTION_OVERRIDE

    /**
     * A synthetic function that is called as a lambda argument when creating a SAM interface object, e.g.,
     * ```
     * val isEven = <caret>IntPredicate { it % 2 == 0 }
     * ```
     */
    SAM_CONSTRUCTOR,

    /**
     * Consider the following code:
     * ```
     * interface A { fun x() }
     * interface B { fun x() }
     *
     * interface C : A, B
     * ```

internal fun FirCallableSymbol<*>.computeImportableName(useSiteSession: FirSession): FqName? {
    if (callableId.isLocal) return null

    // SAM constructors are synthetic, but can be imported
    if (origin is FirDeclarationOrigin.SamConstructor) return callableId.asSingleFqName()

    // if classId == null, callable is topLevel
    val containingClassId = callableId.classId
        ?: return callableId.asSingleFqName()