import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Target(ANNOTATION_TYPE)
@Retention(RUNTIME)
@Documented

            printer: PrettyPrinter,
        ) {
            printer {
                printCollection(qualifiers, separator = ".") { qualifier ->
                    qualifier.render(analysisSession, type, typeRenderer, printer)
                }
            }
        }
    }

    public object WITH_QUALIFIED_NAMES : KaClassTypeQualifierRenderer {
        override fun renderClassTypeQualifier(
            analysisSession: KaSession,

    private final String qualifier;
    private final AbstractScheme scheme;

    public VersionNumber(int major, int minor, int micro, @Nullable String qualifier) {
        this(major, minor, micro, 0, qualifier, DEFAULT_SCHEME);
    }

    public VersionNumber(int major, int minor, int micro, int patch, @Nullable String qualifier) {
        this(major, minor, micro, patch, qualifier, PATCH_SCHEME);
    }

            getNumericParts() >> [1, 3]
        }

        expect:
        def versionComparator = comparator.asVersionComparator()
        versionComparator.compare(v1, v2) < 0
    }

    def "special qualifiers are treated differently"() {
        expect:
        compare(smaller, larger) < 0
        compare(larger, smaller) > 0
        compare(smaller, smaller) == 0
        compare(larger, larger) == 0

import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.psi.KtThisExpression
import org.jetbrains.kotlin.psi.KtUserType

/**
 * @property removeThis If set to `true`, reference shortener will detect redundant `this` qualifiers
 * and will collect them to [ShortenCommand.listOfQualifierToShortenInfo].
 * @property removeThisLabels If set to `true`, reference shortener will detect redundant labels on `this` expressions,

    private final Type type;
    private final @Nullable Object qualifier;

    private int hash;

    protected Key() {
        this(null);
    }

    protected Key(@Nullable Object qualifier) {
        this.type = Types.simplifyType(getTypeParameter());
        this.qualifier = qualifier;
    }

    protected Key(Type type, @Nullable Object qualifier) {
        this.type = Types.simplifyType(type);

    private final String qualifier;
    private final AbstractScheme scheme;
    private boolean deprecationLogged;

    public VersionNumber(int major, int minor, int micro, @Nullable String qualifier) {
        this(major, minor, micro, 0, qualifier, DEFAULT_SCHEME, true);
    }

    public VersionNumber(int major, int minor, int micro, int patch, @Nullable String qualifier) {

                if (buildNumber == null) {
                    qualifier = part2;
                }
            } else {
                qualifier = part2;
            }
        }

        if ((!part1.contains(".")) && !part1.startsWith("0")) {
            majorVersion = tryParseInt(part1);
            if (majorVersion == null) {
                // qualifier is the whole version, including "-"

                appendLine("[type] $it${shortenedRef?.let { ref -> " -> $ref" } ?: ""}")
            }
        }
        shortening.listOfQualifierToShortenInfo.forEach { (qualifier, shortenedRef) ->
            qualifier.element?.text?.let {
                appendLine("[qualifier] $it${shortenedRef?.let { ref -> " -> $ref" } ?: ""}")
            }
        }
        shortening.thisLabelsToShorten.forEach { thisLabel ->

	var fset *token.FileSet
	var qf Qualifier
	if check != nil {
		fset = check.fset
		qf = check.qualifier
	}
	return sprintf(fset, qf, false, format, args...)
}

func (check *Checker) trace(pos token.Pos, format string, args ...any) {
	fmt.Printf("%s:\t%s%s\n",
		check.fset.Position(pos),
		strings.Repeat(".  ", check.indent),
		sprintf(check.fset, check.qualifier, true, format, args...),
	)
}