typeutils.h

Go to the documentation of this file.

/*
   Copyright 2007 David Nolden <[email protected]>
   Copyright 2014 Sven Brauch <[email protected]>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
#ifndef KDEVPLATFORM_TYPEUTILS_H
#define KDEVPLATFORM_TYPEUTILS_H
 
#include <language/languageexport.h>
#include "abstracttype.h"
#include "unsuretype.h"
#include "integraltype.h"
 
#include <type_traits>
 
namespace KDevelop {
class TopDUContext;
}
 
namespace TypeUtils {
KDEVPLATFORMLANGUAGE_EXPORT KDevelop::AbstractType::Ptr targetType(const KDevelop::AbstractType::Ptr& type,
                                                                   const KDevelop::TopDUContext* topContext,
                                                                   bool* constant = nullptr);
KDEVPLATFORMLANGUAGE_EXPORT KDevelop::AbstractType::Ptr targetTypeKeepAliases(const KDevelop::AbstractType::Ptr& type,
                                                                              const KDevelop::TopDUContext* topContext,
                                                                              bool* constant = nullptr);
KDEVPLATFORMLANGUAGE_EXPORT KDevelop::AbstractType::Ptr unAliasedType(const KDevelop::AbstractType::Ptr& type);
 
KDEVPLATFORMLANGUAGE_EXPORT KDevelop::AbstractType::Ptr resolveAliasType(
    const KDevelop::AbstractType::Ptr& eventualAlias);
 
KDEVPLATFORMLANGUAGE_EXPORT bool isUsefulType(KDevelop::AbstractType::Ptr type);
 
template <typename LanguageUnsureType = KDevelop::UnsureType>
KDevelop::AbstractType::Ptr mergeTypes(KDevelop::AbstractType::Ptr type, const KDevelop::AbstractType::Ptr& newType)
{
    static_assert(std::is_base_of<KDevelop::UnsureType, LanguageUnsureType>::value,
                  "LanguageUnsureType must inherit from KDevelop::UnsureType");
 
    auto unsure = LanguageUnsureType::Ptr::dynamicCast(type);
    auto newUnsure = LanguageUnsureType::Ptr::dynamicCast(newType);
    typename LanguageUnsureType::Ptr ret;
 
    // both types are unsure, so join the list of possible types.
    if (unsure && newUnsure) {
        int len = newUnsure->typesSize();
        for (int i = 0; i < len; i++) {
            unsure->addType(newUnsure->types()[i]);
        }
 
        ret = unsure;
    }
    // one of them is unsure, use that and add the other one
    else if (unsure) {
        if (isUsefulType(newType)) {
            unsure->addType(newType->indexed());
        }
        ret = unsure;
    } else if (newUnsure) {
        KDevelop::UnsureType::Ptr createdUnsureType(static_cast<KDevelop::UnsureType*>(newUnsure->clone()));
        if (isUsefulType(type)) {
            createdUnsureType->addType(type->indexed());
        }
        ret = LanguageUnsureType::Ptr::staticCast(createdUnsureType);
    } else {
        unsure = typename LanguageUnsureType::Ptr(new LanguageUnsureType());
        if (isUsefulType(type)) {
            unsure->addType(type->indexed());
        }
        if (isUsefulType(newType)) {
            unsure->addType(newType->indexed());
        }
        if (!unsure->typesSize()) {
            return KDevelop::AbstractType::Ptr(new KDevelop::IntegralType(KDevelop::IntegralType::TypeMixed));
        }
        ret = unsure;
    }
    if (ret->typesSize() == 1) {
        return ret->types()[0].abstractType();
    } else {
        return KDevelop::AbstractType::Ptr::staticCast(ret);
    }
}
}
 
#endif