val annotations = type.annotations
            .filter { it.annotationClass?.classId != StandardClassIds.Annotations.ExtensionFunctionType }

        printer.printCollectionIfNotEmpty(annotations, separator = " ", postfix = "  ") {
            renderTypeAnnotationDebug(it, printer)
        }
    }

    private fun Fe10AnalysisContext.renderTypeAnnotationDebug(annotation: AnnotationDescriptor, printer: PrettyPrinter) {

                .filter { declarationRenderer.typeParametersFilter.filter(analysisSession, it, symbol) }
                .ifEmpty { return }
            printer.printCollection(typeParameters, prefix = "<", postfix = ">") { typeParameter ->
                declarationRenderer.codeStyle.getSeparatorBetweenAnnotationAndOwner(analysisSession, typeParameter).separated(

            val valueParameters = when (symbol) {
                is KaFunctionLikeSymbol -> symbol.valueParameters
                else -> return
            }
            printer.printCollection(valueParameters, prefix = "(", postfix = ")") {
                declarationRenderer.renderDeclaration(analysisSession, it, printer)
            }
        }
    }
}

            separator = ",\n  ",
            prefix = "{\n  ",
            postfix = "\n}"
        ) { (k, v) -> "${k?.let { stringRepresentation(it).indented() }} -> (${v?.let { stringRepresentation(it).indented() }})" }
        is Collection<*> -> if (isEmpty()) "[]" else joinToString(
            separator = ",\n  ",
            prefix = "[\n  ",
            postfix = "\n]"
        ) {

            annotationRenderer: KaAnnotationRenderer,
            printer: PrettyPrinter,
        ) {
            if (annotation.arguments.isEmpty()) return
            printer.printCollection(annotation.arguments, prefix = "(", postfix = ")") { argument ->
                append(argument.name.render())
                append(" = ")
                append(KaAnnotationValueRenderer.render(argument.expression))
            }
        }
    }
}

                        {
                            (symbol.getContainingSymbol() as? KaNamedSymbol)?.name?.let { printer.append(it.render()) }
                            printer.printCollection(symbol.valueParameters, prefix = "(", postfix = ")") {
                                declarationRenderer.typeRenderer.renderType(analysisSession, it.returnType, printer)
                            }
                        }
                    )
                }

                        append(part.name)
                        if (part.typeArgumentList.typeArguments.isNotEmpty()) {
                            part.typeArgumentList.typeArguments.joinTo(this, prefix = "<", postfix = ">") { it.renderTypeAsKotlinType() }
                        }
                    }
                }
                if (isMarkedNullable) "$renderedQualifier?" else renderedQualifier
            }

                            }
                        }
                        printCollection(symbol.entries, prefix = "(", postfix = ")") {
                            with(rendererWithoutValVar) {
                                renderDeclaration(analysisSession, it, this@printCollection)
                            }
                        }

                annotationClassSymbol.annotationApplicableTargets
                    ?.map { it.name }
                    ?.sorted()
                    ?.joinToString(prefix = "[", separator = ", ", postfix = "]")
                    ?: "<null>"

            buildString {
                appendLine("${KtAnnotationEntry::class.simpleName}: ${annotationEntry.text}")
                appendLine()

                }

                declarationRenderer.nameRenderer.renderName(analysisSession, symbol, declarationRenderer, printer)

                printer.printCollection(symbol.valueParameters, prefix = "(", postfix = ")") {
                    declarationRenderer.typeRenderer.renderType(analysisSession, it.returnType, printer)
                }

                withPrefix(": ") {