printer.append(value.callableId?.asSingleFqName()?.render())
            }

            is KtConstantAnnotationValue -> {
                printer.append(value.constantValue.constantValueKind.asString)
                    .append("(")
                    .append(value.constantValue.value.toString())
                    .append(")")
            }

                    qualifierClassId.asSingleFqName(),
                    importAllInParent
                )
            }
            // The class with name `classId.shortClassName` happens to be the same class referenced by this qualified access.
            availableClassifier.symbol.classIdIfExists == qualifierClassId -> {

     * is somehow changed, then we want to keep the wrapper.
     *
     * Such substitute overrides happen because of inheritance.
     *
     * If the declaration references only its own type parameters, or parameters from the outer declarations, then

    add(FirErrors.REDUNDANT_NULLABLE) { firDiagnostic ->
        RedundantNullableImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.PLATFORM_CLASS_MAPPED_TO_KOTLIN) { firDiagnostic ->
        PlatformClassMappedToKotlinImpl(
            firDiagnostic.a,
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }

        // adding the name/ordinal parameters manually.
        append("Ljava/lang/String;")
        append("I")
    }
    for (param in method.parameterList.parameters) {
        append(getBinaryPresentationWithCorrection(param.type))
    }
    append(")")
    append(getBinaryPresentationWithCorrection(Optional.ofNullable(method.returnType).orElse(PsiType.VOID)))
}

        return KtFirAnalysisSession.createAnalysisSessionByFirResolveSession(firResolveSession, validityToken)
    }

    override fun clearCaches() {
        cache.clear()
    }

    /**
     * Note: Races cannot happen because the listener is guaranteed to be invoked in a write action.
     */
    internal class SessionInvalidationListener(val project: Project) : LLFirSessionInvalidationListener {

        val signature = StringCharacterIterator(canonicalSignature)
        val javaType = SignatureParsing.parseTypeString(signature, StubBuildingVisitor.GUESSING_MAPPER)
        val typeInfo = TypeInfo.fromString(javaType, false)
        val typeText = TypeInfo.createTypeText(typeInfo) ?: return null

        return SyntheticTypeElement(useSitePosition, typeText)
    }

    ): FirLiteralExpression<String>? {
        val concatenated = buildString {
            for (arg in stringConcatenationCall.arguments) {
                val evaluated = evaluate(arg, mode) ?: return null
                append(evaluated.value.toString())
            }
        }

        return ConstantValueKind.String.toLiteralExpression(stringConcatenationCall.source, concatenated)
    }

    private fun evaluateFunctionCall(

    val signature = StringCharacterIterator(canonicalSignature)
    val javaType = SignatureParsing.parseTypeString(signature, StubBuildingVisitor.GUESSING_MAPPER)
    val typeInfo = TypeInfo.fromString(javaType, false)
    val typeText = TypeInfo.createTypeText(typeInfo) ?: return null

    return SyntheticTypeElement(useSitePosition, typeText)
}

        if (function.bodyBlockExpression != null) {
            // Given `fun f(...): R { blockExpression }`, `{ blockExpression }` is mapped to the enclosing anonymous function,
            // which may raise an exception if we attempt to retrieve, e.g., callable declaration from it.
            return null
        }