}

    interface PluginAmbiguousInterceptedSymbol : KtFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = PluginAmbiguousInterceptedSymbol::class
        val names: List<String>
    }

    interface ResolutionToClassifier : KtFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = ResolutionToClassifier::class
        val classSymbol: KtClassLikeSymbol
    }

            }
        }
    }

    private fun KtFirPsiJavaClassSymbol.mayHaveDeprecation(): Boolean {
        if (!hasAnnotations) return false

        // Check the simple names of the Java annotations. While presence of such an annotation name does not prove deprecation, it is a
        // necessary condition for it. Type aliases are not a problem here: Java code cannot access Kotlin type aliases. (Currently,

                    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)
                        else null

            // KtClass, KtObjectDeclaration, KtTypeAlias has no expression children
            is KtClassLikeDeclaration ->
                false // has no expression children

            // Simple names do not have expression children
            // Labels, operations, references by name
            is KtSimpleNameExpression ->
                false

        val parameterSignatureByName = signature.valueParameters.associateBy {
            // ResolvedCall.valueArguments have their names affected by the `@ParameterName` annotations,
            // so we use `name` instead of `symbol.name`
            it.name
        }