*/
public sealed class KaAnnotationValue(override val token: KaLifetimeToken) : KaLifetimeOwner {
    public abstract val sourcePsi: KtElement?
}

public typealias KtAnnotationValue = KaAnnotationValue

/**
 * This represents an unsupported expression used as an annotation value.
 */
public class KaUnsupportedAnnotationValue @KaAnalysisApiInternals constructor(
    token: KaLifetimeToken
) : KaAnnotationValue(token) {

                                        builder.functionLikeBuilder.buildConstructorSymbol(resolvedSymbol)
                                    },
                                    token = token
                                ),
                                token
                            )
                        } else null
                    }

                    is FirNamedFunctionSymbol -> {

        backingArguments += KaTypeArgumentWithVariance(type, variance, type.token)
    }

    public class ByClassId(classId: ClassId, override val token: KaLifetimeToken) : KaClassTypeBuilder() {
        public val classId: ClassId by validityAsserted(classId)
    }

    public class BySymbol(symbol: KaClassLikeSymbol, override val token: KaLifetimeToken) : KaClassTypeBuilder() {

		return token, -1
	}
	i := strings.Index(token, getKeySeparator())
	if i < 0 {
		return token, -1
	}
	nodeIndex, err := strconv.Atoi(token[i+1:])
	if err != nil {
		return token, -1
	}
	subToken = token[:i]
	return subToken, nodeIndex
}

func proxyRequestByToken(ctx context.Context, w http.ResponseWriter, r *http.Request, token string) (string, bool) {
	subToken, nodeIndex := parseRequestToken(token)

import kotlin.reflect.KClass

internal class KaFe10DiagnosticProvider(
    override val analysisSession: KaFe10Session
) : KaDiagnosticProvider(), KaFe10SessionComponent {
    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun getDiagnosticsForElement(element: KtElement, filter: KaDiagnosticCheckerFilter): Collection<KaDiagnosticWithPsi<*>> {

                    index = null,
                    constructorSymbol = null,
                    token = token
                ),
                token
            )
        }
        else -> {
            KaConstantAnnotationValue(toKtConstantValue(), token)
        }
    }
}

private class ClassLiteralResolutionResult(val type: KaType, val classId: ClassId)

    private val useSiteSession: FirSession
        get() = builder.rootSession

    override val token: KaLifetimeToken
        get() = builder.token

    override fun isEmpty(): Boolean = withValidityAssertion {
        // isEmpty check is possible on a callable symbol directly as annotations cannot be moved from a containing

    override val token: KaLifetimeToken
        get() = owner.token

    override val origin: KaSymbolOrigin
        get() = withValidityAssertion { KaSymbolOrigin.JS_DYNAMIC }

    override val psi: PsiElement?
        get() = withValidityAssertion { null }

    override val annotations: KaAnnotationList
        get() = withValidityAssertion { KaEmptyAnnotationList(token) }

    override val name: Name

                        sourcePsi = null,
                        token
                    )
                },
                sourcePsi = null,
                token
            ),
            token
        )

        return listOf(value)
    }

    return emptyList()
}

                FirAnnotationValueConverter.toNamedConstantValue(builder.analysisSession, mapAnnotationParameters(firAnnotation), builder)
            }
        }
    }

    override val token: KaLifetimeToken
        get() = builder.token

    private val useSiteSession: FirSession
        get() = builder.rootSession

    override fun isEmpty(): Boolean = withValidityAssertion {
        return coneType.customAnnotations.isEmpty()