if (RELEASE_QUALIFIERS.contains(qualifier)) {
                return String.valueOf(QUALIFIERS.indexOf(""));
            }

            int i = QUALIFIERS.indexOf(qualifier);

            // Just returning an Integer with the index here is faster, but requires a lot of if/then/else to check for
            // -1

            .toList()
            .asReversed()

        val qualifyingReferences = qualifiers.mapIndexed { index, qualifier ->
            // We want to handle qualified calls like `foo.Bar.Baz()`, but not like `foo.Bar().Baz()`
            if (qualifier is KtCallExpression && index != qualifiers.lastIndex) return null

            qualifier.referenceExpression() as? KtNameReferenceExpression ?: return null
        }

) : KtClassErrorType(), KtFe10Type {
    init {
        check(fe10Type.kind.isUnresolved) {
            "Expected unresolved ErrorType but ${fe10Type.kind} found for $fe10Type"
        }
    }

    override val qualifiers: List<KtClassTypeQualifier.KtUnresolvedClassTypeQualifier>
        get() = withValidityAssertion {
            fe10Type.formatParams.first().split('.').map {

            }

            qualifier.getCalleeExpressionIfAny() as? KtNameReferenceExpression
                ?: errorWithAttachment("Cannot get referenced name from '${qualifier::class}'") {
                    withPsiEntry("qualifier", qualifier)
                }
        }

        override val referencedByName: Name
            get() = typeNameReference.getReferencedNameAsName()

    override val nullability: KtTypeNullability
        get() = withValidityAssertion { fe10Type.ktNullability }

    override val qualifiers: List<KtClassTypeQualifier.KtResolvedClassTypeQualifier>
        get() = withValidityAssertion {
            KtFe10JvmTypeMapperContext.getNestedType(fe10Type).allInnerTypes.map { innerType ->

) : KtUsualClassType(), KtFe10Type {
    override fun asStringForDebugging(): String = withValidityAssertion { fe10Type.asStringForDebugging(analysisContext) }

    override val qualifiers: List<KtClassTypeQualifier.KtResolvedClassTypeQualifier>
        get() = withValidityAssertion {
            val nestedType = KtFe10JvmTypeMapperContext.getNestedType(fe10Type)
            val nonInnerQualifiers =

     * when we shorten [qualifier].
     */
    private fun removeRedundantElements(qualifier: KtElement) {
        typesToShorten.removeAll { it.element.qualifier?.isInsideOf(qualifier) == true }
        qualifiersToShorten.removeAll { it.element.receiverExpression.isInsideOf(qualifier) }
    }

     *
     * To properly resolve qualifier parts in the middle,
     * we need to resolve the whole qualifier to understand which parts of the qualifier are package or class qualifiers.
     * And then we will be able to resolve the qualifier selected by the user to the proper class, package or callable.
     *
     * It's possible that the whole qualifier is invalid, in this case we still want to resolve our [selectedFqName].

            "0"
        };

        checkVersionsArrayEqual(arr);
    }

    /**
     * Test <a href="https://issues.apache.org/jira/browse/MNG-6964">MNG-6964</a> edge cases
     * for qualifiers that start with "-0.", which was showing A == C and B == C but A &lt; B.
     */
    @Test
    void testMng6964() {
        String a = "1-0.alpha";
        String b = "1-0.beta";
        String c = "1";

    @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/qualified")
    @TestDataPath("$PROJECT_ROOT")
    public class Qualified {
      @Test
      public void testAllFilesPresentInQualified() {
        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/qualified"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
      }