Method areTypesEqual

plugins/qmljs/duchain/declarationbuilder.cpp:1474–1532

}

bool DeclarationBuilder::areTypesEqual(const AbstractType::Ptr& a, const AbstractType::Ptr& b)
{
    if (!a || !b) {
        return true;
    }

    if (a->whichType() == AbstractType::TypeUnsure || b->whichType() == AbstractType::TypeUnsure) {
        // Don't try to guess something if one of the types is unsure
        return true;
    }

    const auto bIntegral = b.dynamicCast<IntegralType>();
    if (bIntegral && (bIntegral->dataType() == IntegralType::TypeString || bIntegral->dataType() == IntegralType::TypeMixed)) {
        // In QML/JS, a string can be converted to nearly everything else, similarly ignore mixed types
        return true;
    }

    const auto aIntegral = a.dynamicCast<IntegralType>();
    if (aIntegral && (aIntegral->dataType() == IntegralType::TypeString || aIntegral->dataType() == IntegralType::TypeMixed)) {
        // In QML/JS, nearly everything can be to a string, similarly ignore mixed types
        return true;
    }
    if (aIntegral && bIntegral) {
        if (isNumeric(aIntegral) && isNumeric(bIntegral)) {
            // Casts between integral types is possible
            return true;
        }
    }

    if (a->whichType() == AbstractType::TypeEnumeration && b->whichType() == AbstractType::TypeEnumerator) {
        return enumContainsEnumerator(a, b);
    } else if (a->whichType() == AbstractType::TypeEnumerator && b->whichType() == AbstractType::TypeEnumeration) {
        return enumContainsEnumerator(b, a);
    }

    {
        auto aId = dynamic_cast<const IdentifiedType*>(a.constData());
        auto bId = dynamic_cast<const IdentifiedType*>(b.constData());
        if (aId && bId && aId->qualifiedIdentifier() == bId->qualifiedIdentifier())
            return true;
    }

    {
        auto aStruct = a.dynamicCast<StructureType>();
        auto bStruct = b.dynamicCast<StructureType>();
        if (aStruct && bStruct) {
            auto top = currentContext()->topContext();
            auto aDecl = dynamic_cast<ClassDeclaration*>(aStruct->declaration(top));
            auto bDecl = dynamic_cast<ClassDeclaration*>(bStruct->declaration(top));
            if (aDecl && bDecl) {
                if (aDecl->isPublicBaseClass(bDecl, top) || bDecl->isPublicBaseClass(aDecl, top)) {
                    return true;
                }
            }
        }
    }

    return a->equals(b.constData());