val callableId = symbol.callableIdIfNonLocal ?: return emptyList()
                            val fqName = callableId.asSingleFqName()
                            val classFqName = callableId.classId?.asSingleFqName()
                            // either it is a member declaration
                            if (classFqName != null) {

            return canShorten(fqName, availableCallable.callableId.asSingleFqName()) { callableShortenStrategy(availableCallable) }
        }

        resolvedSymbols.firstIsInstanceOrNull<KtClassLikeSymbol>()?.firSymbol?.let { availableClassifier ->
            return canShorten(fqName, availableClassifier.classId.asSingleFqName()) { classShortenStrategy(availableClassifier) }
        }

        return false

            }
        }

    override fun hasAnnotation(classId: ClassId, useSiteTargetFilter: AnnotationUseSiteTargetFilter): Boolean = withValidityAssertion {
        fe10Annotations.hasAnnotation(classId.asSingleFqName())
    }

    override fun annotationsByClassId(
        classId: ClassId,
        useSiteTargetFilter: AnnotationUseSiteTargetFilter,
    ): List<KtAnnotationApplicationWithArgumentsInfo> = withValidityAssertion {

        with(printer) {
            append("@")

            if (classId != null) {
                append("R|")
                renderFqName(classId.asSingleFqName(), printer)
                append("|")
            } else {
                print("<ERROR TYPE REF>")
            }

    override fun buildClassType(builder: KtClassTypeBuilder): KtClassType {
        val descriptor: ClassDescriptor? = when (builder) {
            is KtClassTypeBuilder.ByClassId -> {
                val fqName = builder.classId.asSingleFqName()
                analysisContext.resolveSession
                    .getTopLevelClassifierDescriptors(fqName, NoLookupLocation.FROM_IDE)
                    .firstIsInstanceOrNull()
            }

        return upperBounds.firstOrNull() ?: builtIns.nullableAnyType
    }

    override fun continuationTypeConstructor(): TypeConstructorMarker {
        val continuationFqName = StandardClassIds.Continuation.asSingleFqName()
        val foundClasses = resolveSession.getTopLevelClassifierDescriptors(continuationFqName, NoLookupLocation.FROM_IDE)
        return foundClasses.firstOrNull()?.typeConstructor

                    }

                    is FirNamedFunctionSymbol -> {
                        // arrayOf call with a single vararg argument.
                        if (resolvedSymbol.callableId.asSingleFqName() in ArrayFqNames.ARRAY_CALL_FQ_NAMES)
                            argumentList.arguments.singleOrNull()?.convertConstantExpression(builder)
                                ?: KtArrayAnnotationValue(emptyList(), sourcePsi, token)

            fun referencedClassIdAndQualifiedAccessMatch(
                qualifiedAccessSegments: List<String>
            ): Boolean {
                val referencedClassIdSegments =
                    referencedClassId.asSingleFqName().pathSegments()
                        .takeLast(qualifiedAccessSegments.size)
                        .map { it.identifierOrNullIfSpecial }
                return referencedClassIdSegments == qualifiedAccessSegments