val sortedUsedDeclarations = importsAnalysis.usedDeclarations
                .toSortedMap(compareBy { importPath -> importPath.toString() })
                .mapValues { (_, importedNames) -> importedNames.sorted() }

            appendLine("USED DECLARATIONS:")
            for ((path, elements) in sortedUsedDeclarations) {
                appendLine()
                appendLine("Declaration: $path")

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

            buildString {

                        + getBoundKeys().stream()
                                .map(Key::toString)
                                .map(String::trim)
                                .sorted()
                                .distinct()
                                .collect(Collectors.joining("\n - ", " - ", "")));
            }
        };
        injector.bindScope(SessionScoped.class, () -> {

        }

        analyseForTest(ktFile) {
            val diagnosticsInFile =
                ktFile.collectDiagnosticsForFile(KaDiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS).map { it.getKey() }.sorted()
            val diagnosticsFromElements = buildList {
                ktFile.accept(object : KtTreeVisitorVoid() {
                    override fun visitKtElement(element: KtElement) {

    ): String {
        if (symbols.isEmpty()) return UNRESOLVED_REFERENCE_RESULT

        val sortedSymbols = symbols.map { renderResolveResult(it, renderPsiClassName, renderer, additionalInfo) }.sorted()
        if (sortedSymbols.size == 1) {
            return sortedSymbols.single()
        }

        return sortedSymbols
            .withIndex()

    appendLine("Callable names:")
    withIndent {
        renderSortedNames(scope.getPossibleCallableNames())
    }
}

private fun PrettyPrinter.renderSortedNames(names: Set<Name>) {
    names.sorted().forEach { appendLine(it.toString()) }

        testServices: TestServices,
    ) {
        val invalidatedModuleDescriptions = invalidatedSessions
            .map { getSessionKtModule(it).toString() }
            .distinct()
            .sorted()

        val actualText = buildString {
            appendLine("Module names of invalidated sessions:")
            invalidatedModuleDescriptions.forEach { appendLine(it) }
        }

        // ensure canonical order of standard lifecycles
        return lifecyclesMap.values().stream()
                .peek(l -> Objects.requireNonNull(l.getId(), "A lifecycle must have an id."))
                .sorted(Comparator.comparing(Lifecycle::getId, comparator))
                .collect(Collectors.toList());
    }

    private Map<String, Lifecycle> lookupLifecycles() {

    }

    @Override
    public void addResource(@Nonnull Project project, @Nonnull ProjectScope scope, @Nonnull Resource resource) {
        // TODO: we should not modify the underlying model here, but resources should be stored
        // TODO: in a separate field in the project, however, that could break v3 plugins
        MavenProject prj = getMavenProject(nonNull(project, "project"));

public typealias KtReferenceShortener = KaReferenceShortener

public interface KaReferenceShortenerMixIn : KaSessionMixIn {

    /**
     * Collects possible references to shorten. By default, it shortens a fully-qualified members to the outermost class and does not
     * shorten enum entries.  In case of KDoc shortens reference only if it is already imported.
     *
     * N.B. This API is not implemented for the FE10 implementation!