qjsprimitivevalue.h

Go to the documentation of this file.

// Copyright (C) 2020 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant
 
#ifndef QJSPRIMITIVEVALUE_H
#define QJSPRIMITIVEVALUE_H
 
#include <QtQml/qtqmlglobal.h>
#include <QtQml/qjsnumbercoercion.h>
 
#include <QtCore/qstring.h>
#include <QtCore/qnumeric.h>
#include <QtCore/qvariant.h>
 
#include <variant>
#include <cmath>
 
QT_BEGIN_NAMESPACE
 
namespace QV4 { struct ExecutionEngine; }
 
struct QJSPrimitiveUndefined {};
struct QJSPrimitiveNull {};
 
class QJSPrimitiveValue
{
    template<typename Concrete>
    struct StringNaNOperators
    {
        static constexpr double op(const QString &, QJSPrimitiveUndefined)
        {
            return std::numeric_limits<double>::quiet_NaN();
        }
 
        static constexpr double op(QJSPrimitiveUndefined, const QString &)
        {
            return std::numeric_limits<double>::quiet_NaN();
        }
 
        static double op(const QString &lhs, QJSPrimitiveNull) { return op(lhs, 0); }
        static double op(QJSPrimitiveNull, const QString &rhs) { return op(0, rhs); }
 
        template<typename T>
        static double op(const QString &lhs, T rhs)
        {
            return Concrete::op(numberFromString(lhs).toDouble(), rhs);
        }
 
        template<typename T>
        static double op(T lhs, const QString &rhs)
        {
            return Concrete::op(lhs, numberFromString(rhs).toDouble());
        }
 
        static double op(const QString &lhs, const QString &rhs)
        {
            return Concrete::op(numberFromString(lhs).toDouble(), numberFromString(rhs).toDouble());
        }
    };
 
    struct AddOperators {
        static constexpr double op(double lhs, double rhs) { return lhs + rhs; }
        static bool opOverflow(int lhs, int rhs, int *result)
        {
            return qAddOverflow(lhs, rhs, result);
        }
 
        template<typename T>
        static QString op(const QString &lhs, T rhs)
        {
            return lhs + QJSPrimitiveValue(rhs).toString();
        }
 
        template<typename T>
        static QString op(T lhs, const QString &rhs)
        {
            return QJSPrimitiveValue(lhs).toString() + rhs;
        }
 
        static QString op(const QString &lhs, const QString &rhs) { return lhs + rhs; }
    };
 
    struct SubOperators : private StringNaNOperators<SubOperators> {
        static constexpr double op(double lhs, double rhs) { return lhs - rhs; }
        static bool opOverflow(int lhs, int rhs, int *result)
        {
            return qSubOverflow(lhs, rhs, result);
        }
 
        using StringNaNOperators::op;
    };
 
    struct MulOperators : private StringNaNOperators<MulOperators> {
        static constexpr double op(double lhs, double rhs) { return lhs * rhs; }
        static bool opOverflow(int lhs, int rhs, int *result)
        {
            // compare mul_int32 in qv4math_p.h
            auto hadOverflow = qMulOverflow(lhs, rhs, result);
            if (((lhs < 0) ^ (rhs < 0)) && (*result == 0))
                return true; // result must be negative 0, does not fit into int
            return hadOverflow;
        }
 
        using StringNaNOperators::op;
    };
 
    struct DivOperators : private StringNaNOperators<DivOperators> {
        static constexpr double op(double lhs, double rhs)  {
            // Without is_iec559, we don't get proper JS semantics
#ifndef Q_OS_INTEGRITY
            static_assert(std::numeric_limits<double>::is_iec559);
#endif
            QT_WARNING_PUSH
            // divide by zero: not an issue with iec559
            QT_WARNING_DISABLE_MSVC(4723)
            return lhs / rhs;
            QT_WARNING_POP
        }
        static constexpr bool opOverflow(int, int, int *)
        {
            return true;
        }
 
        using StringNaNOperators::op;
    };
 
public:
    enum Type : quint8 {
        Undefined,
        Null,
        Boolean,
        Integer,
        Double,
        String
    };
 
    constexpr Type type() const { return Type(d.type()); }
 
    // Prevent casting from Type to int
    QJSPrimitiveValue(Type) = delete;
 
    Q_IMPLICIT constexpr QJSPrimitiveValue() noexcept = default;
    Q_IMPLICIT constexpr QJSPrimitiveValue(QJSPrimitiveUndefined undefined) noexcept : d(undefined) {}
    Q_IMPLICIT constexpr QJSPrimitiveValue(QJSPrimitiveNull null) noexcept : d(null) {}
    Q_IMPLICIT constexpr QJSPrimitiveValue(bool value) noexcept : d(value) {}
    Q_IMPLICIT constexpr QJSPrimitiveValue(int value) noexcept : d(value) {}
    Q_IMPLICIT constexpr QJSPrimitiveValue(double value) noexcept : d(value) {}
    Q_IMPLICIT QJSPrimitiveValue(QString string) noexcept : d(std::move(string)) {}
 
    explicit QJSPrimitiveValue(const QMetaType type, const void *value) noexcept
    {
        switch (type.id()) {
        case QMetaType::UnknownType:
            d = QJSPrimitiveUndefined();
            break;
        case QMetaType::Nullptr:
            d = QJSPrimitiveNull();
            break;
        case QMetaType::Bool:
            d = *static_cast<const bool *>(value);
            break;
        case QMetaType::Int:
            d = *static_cast<const int *>(value);
            break;
        case QMetaType::Double:
            d = *static_cast<const double *>(value);
            break;
        case QMetaType::QString:
            d = *static_cast<const QString *>(value);
            break;
        default:
            // Unsupported. Remains undefined.
            break;
        }
    }
 
    explicit QJSPrimitiveValue(QMetaType type) noexcept
    {
        switch (type.id()) {
        case QMetaType::UnknownType:
            d = QJSPrimitiveUndefined();
            break;
        case QMetaType::Nullptr:
            d = QJSPrimitiveNull();
            break;
        case QMetaType::Bool:
            d = false;
            break;
        case QMetaType::Int:
            d = 0;
            break;
        case QMetaType::Double:
            d = 0.0;
            break;
        case QMetaType::QString:
            d = QString();
            break;
        default:
            // Unsupported. Remains undefined.
            break;
        }
    }
 
    explicit QJSPrimitiveValue(const QVariant &variant) noexcept
        : QJSPrimitiveValue(variant.metaType(), variant.data())
    {
    }
 
    constexpr QMetaType metaType() const  { return d.metaType(); }
    constexpr void *data() { return d.data(); }
    constexpr const void *data() const { return d.data(); }
    constexpr const void *constData() const { return d.data(); }
 
    template<Type type>
    QJSPrimitiveValue to() const {
        if constexpr (type == Undefined)
            return QJSPrimitiveUndefined();
        if constexpr (type == Null)
            return QJSPrimitiveNull();
        if constexpr (type == Boolean)
            return toBoolean();
        if constexpr (type == Integer)
            return toInteger();
        if constexpr (type == Double)
            return toDouble();
        if constexpr (type == String)
            return toString();
 
        Q_UNREACHABLE_RETURN(QJSPrimitiveUndefined());
    }
 
    constexpr bool toBoolean() const
    {
        switch (type()) {
        case Undefined: return false;
        case Null:      return false;
        case Boolean:   return asBoolean();
        case Integer:   return asInteger() != 0;
        case Double: {
            const double v = asDouble();
            return !QJSNumberCoercion::equals(v, 0) && !std::isnan(v);
        }
        case String:    return !asString().isEmpty();
        }
 
        // GCC 8.x does not treat __builtin_unreachable() as constexpr
    #if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900)
        Q_UNREACHABLE_RETURN(false);
    #else
        return false;
    #endif
    }
 
    constexpr int toInteger() const
    {
        switch (type()) {
        case Undefined: return 0;
        case Null:      return 0;
        case Boolean:   return asBoolean();
        case Integer:   return asInteger();
        case Double:    return QJSNumberCoercion::toInteger(asDouble());
        case String:    return numberFromString(asString()).toInteger();
        }
 
        // GCC 8.x does not treat __builtin_unreachable() as constexpr
    #if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900)
        Q_UNREACHABLE_RETURN(0);
    #else
        return 0;
    #endif
    }
 
    constexpr double toDouble() const
    {
        switch (type()) {
        case Undefined: return std::numeric_limits<double>::quiet_NaN();
        case Null:      return 0;
        case Boolean:   return asBoolean();
        case Integer:   return asInteger();
        case Double:    return asDouble();
        case String:    return numberFromString(asString()).toDouble();
        }
 
        // GCC 8.x does not treat __builtin_unreachable() as constexpr
    #if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900)
        Q_UNREACHABLE_RETURN({});
    #else
        return {};
    #endif
    }
 
    QString toString() const
    {
        switch (type()) {
        case Undefined: return QStringLiteral("undefined");
        case Null:      return QStringLiteral("null");
        case Boolean:   return asBoolean() ? QStringLiteral("true") : QStringLiteral("false");
        case Integer:   return QString::number(asInteger());
        case Double: {
            const double result = asDouble();
            if (std::isnan(result))
                return QStringLiteral("NaN");
            if (std::isfinite(result))
                return toString(result);
            if (result > 0)
                return QStringLiteral("Infinity");
            return QStringLiteral("-Infinity");
        }
        case String: return asString();
        }
 
        Q_UNREACHABLE_RETURN(QString());
    }
 
    QVariant toVariant() const
    {
        switch (type()) {
        case Undefined: return QVariant();
        case Null:      return QVariant::fromValue<std::nullptr_t>(nullptr);
        case Boolean:   return QVariant(asBoolean());
        case Integer:   return QVariant(asInteger());
        case Double:    return QVariant(asDouble());
        case String:    return QVariant(asString());
        }
 
        Q_UNREACHABLE_RETURN(QVariant());
    }
 
    friend inline QJSPrimitiveValue operator+(const QJSPrimitiveValue &lhs,
                                              const QJSPrimitiveValue &rhs)
    {
        return operate<AddOperators>(lhs, rhs);
    }
 
    friend inline QJSPrimitiveValue operator-(const QJSPrimitiveValue &lhs,
                                              const QJSPrimitiveValue &rhs)
    {
        return operate<SubOperators>(lhs, rhs);
    }
 
    friend inline QJSPrimitiveValue operator*(const QJSPrimitiveValue &lhs,
                                              const QJSPrimitiveValue &rhs)
    {
        return operate<MulOperators>(lhs, rhs);
    }
 
    friend inline QJSPrimitiveValue operator/(const QJSPrimitiveValue &lhs,
                                              const QJSPrimitiveValue &rhs)
    {
        return operate<DivOperators>(lhs, rhs);
    }
 
    friend inline QJSPrimitiveValue operator%(const QJSPrimitiveValue &lhs,
                                              const QJSPrimitiveValue &rhs)
    {
        switch (lhs.type()) {
        case Null:
        case Boolean:
        case Integer:
            switch (rhs.type()) {
            case Boolean:
            case Integer: {
                const int leftInt = lhs.toInteger();
                const int rightInt = rhs.toInteger();
                if (leftInt >= 0 && rightInt > 0)
                    return leftInt % rightInt;
                Q_FALLTHROUGH();
            }
            case Undefined:
            case Null:
            case Double:
            case String:
                break;
            }
            Q_FALLTHROUGH();
        case Undefined:
        case Double:
        case String:
            break;
        }
 
        return std::fmod(lhs.toDouble(), rhs.toDouble());
    }
 
    QJSPrimitiveValue &operator++()
    {
        // ++a is modeled as a -= (-1) to avoid the potential string concatenation
        return (*this = operate<SubOperators>(*this, -1));
    }
 
    QJSPrimitiveValue operator++(int)
    {
        // a++ is modeled as a -= (-1) to avoid the potential string concatenation
        QJSPrimitiveValue other = operate<SubOperators>(*this, -1);
        std::swap(other, *this);
        return +other; // We still need to coerce the original value.
    }
 
    QJSPrimitiveValue &operator--()
    {
        return (*this = operate<SubOperators>(*this, 1));
    }
 
    QJSPrimitiveValue operator--(int)
    {
        QJSPrimitiveValue other = operate<SubOperators>(*this, 1);
        std::swap(other, *this);
        return +other; // We still need to coerce the original value.
    }
 
    QJSPrimitiveValue operator+()
    {
        // +a is modeled as a -= 0. That should force it to number.
        return (*this = operate<SubOperators>(*this, 0));
    }
 
    QJSPrimitiveValue operator-()
    {
        return (*this = operate<MulOperators>(*this, -1));
    }
 
    constexpr bool strictlyEquals(const QJSPrimitiveValue &other) const
    {
        const Type myType = type();
        const Type otherType = other.type();
 
        if (myType != otherType) {
            // int -> double promotion is OK in strict mode
            if (myType == Double && otherType == Integer)
                return strictlyEquals(double(other.asInteger()));
            if (myType == Integer && otherType == Double)
                return QJSPrimitiveValue(double(asInteger())).strictlyEquals(other);
            return false;
        }
 
        switch (myType) {
        case Undefined:
        case Null:
            return true;
        case Boolean:
            return asBoolean() == other.asBoolean();
        case Integer:
            return asInteger() == other.asInteger();
        case Double: {
            const double l = asDouble();
            const double r = other.asDouble();
            if (std::isnan(l) || std::isnan(r))
                return false;
            if (qIsNull(l) && qIsNull(r))
                return true;
            return QJSNumberCoercion::equals(l, r);
        }
        case String:
            return asString() == other.asString();
        }
 
        return false;
    }
 
    // Loose operator==, in contrast to strict ===
    constexpr bool equals(const QJSPrimitiveValue &other) const
    {
        const Type myType = type();
        const Type otherType = other.type();
 
        if (myType == otherType)
            return strictlyEquals(other);
 
        switch (myType) {
        case Undefined:
            return otherType == Null;
        case Null:
            return otherType == Undefined;
        case Boolean:
            return QJSPrimitiveValue(int(asBoolean())).equals(other);
        case Integer:
            // prefer rhs bool -> int promotion over promoting both to double
            return otherType == Boolean
                    ? QJSPrimitiveValue(asInteger()).equals(int(other.asBoolean()))
                    : QJSPrimitiveValue(double(asInteger())).equals(other);
        case Double:
            // Promote the other side to double (or recognize lhs as undefined/null)
            return other.equals(*this);
        case String:
            return numberFromString(asString()).parsedEquals(other);
        }
 
        return false;
    }
 
    friend constexpr inline bool operator==(const QJSPrimitiveValue &lhs, const
                                            QJSPrimitiveValue &rhs)
    {
        return lhs.strictlyEquals(rhs);
    }
 
    friend constexpr inline bool operator!=(const QJSPrimitiveValue &lhs,
                                            const QJSPrimitiveValue &rhs)
    {
        return !lhs.strictlyEquals(rhs);
    }
 
    friend constexpr inline bool operator<(const QJSPrimitiveValue &lhs,
                                           const QJSPrimitiveValue &rhs)
    {
        switch (lhs.type()) {
        case Undefined:
            return false;
        case Null: {
            switch (rhs.type()) {
            case Undefined: return false;
            case Null:      return false;
            case Boolean:   return 0 < int(rhs.asBoolean());
            case Integer:   return 0 < rhs.asInteger();
            case Double:    return double(0) < rhs.asDouble();
            case String:    return double(0) < rhs.toDouble();
            }
            break;
        }
        case Boolean: {
            switch (rhs.type()) {
            case Undefined: return false;
            case Null:      return int(lhs.asBoolean()) < 0;
            case Boolean:   return lhs.asBoolean() < rhs.asBoolean();
            case Integer:   return int(lhs.asBoolean()) < rhs.asInteger();
            case Double:    return double(lhs.asBoolean()) < rhs.asDouble();
            case String:    return double(lhs.asBoolean()) < rhs.toDouble();
            }
            break;
        }
        case Integer: {
            switch (rhs.type()) {
            case Undefined: return false;
            case Null:      return lhs.asInteger() < 0;
            case Boolean:   return lhs.asInteger() < int(rhs.asBoolean());
            case Integer:   return lhs.asInteger() < rhs.asInteger();
            case Double:    return double(lhs.asInteger()) < rhs.asDouble();
            case String:    return double(lhs.asInteger()) < rhs.toDouble();
            }
            break;
        }
        case Double: {
            switch (rhs.type()) {
            case Undefined: return false;
            case Null:      return lhs.asDouble() < double(0);
            case Boolean:   return lhs.asDouble() < double(rhs.asBoolean());
            case Integer:   return lhs.asDouble() < double(rhs.asInteger());
            case Double:    return lhs.asDouble() < rhs.asDouble();
            case String:    return lhs.asDouble() < rhs.toDouble();
            }
            break;
        }
        case String: {
            switch (rhs.type()) {
            case Undefined: return false;
            case Null:      return lhs.toDouble() < double(0);
            case Boolean:   return lhs.toDouble() < double(rhs.asBoolean());
            case Integer:   return lhs.toDouble() < double(rhs.asInteger());
            case Double:    return lhs.toDouble() < rhs.asDouble();
            case String:    return lhs.asString() < rhs.asString();
            }
            break;
        }
        }
 
        return false;
    }
 
    friend constexpr inline bool operator>(const QJSPrimitiveValue &lhs, const QJSPrimitiveValue &rhs)
    {
        return rhs < lhs;
    }
 
    friend constexpr inline bool operator<=(const QJSPrimitiveValue &lhs, const QJSPrimitiveValue &rhs)
    {
        if (lhs.type() == String) {
           if (rhs.type() == String)
               return lhs.asString() <= rhs.asString();
           else
               return numberFromString(lhs.asString()) <= rhs;
        }
        if (rhs.type() == String)
            return lhs <= numberFromString(rhs.asString());
 
        if (lhs.isNanOrUndefined() || rhs.isNanOrUndefined())
            return false;
        return !(lhs > rhs);
    }
 
    friend constexpr inline bool operator>=(const QJSPrimitiveValue &lhs, const QJSPrimitiveValue &rhs)
    {
        if (lhs.type() == String) {
           if (rhs.type() == String)
               return lhs.asString() >= rhs.asString();
           else
               return numberFromString(lhs.asString()) >= rhs;
        }
        if (rhs.type() == String)
            return lhs >= numberFromString(rhs.asString());
 
        if (lhs.isNanOrUndefined() || rhs.isNanOrUndefined())
            return false;
        return !(lhs < rhs);
    }
 
private:
    friend class QJSManagedValue;
    friend class QJSValue;
    friend struct QV4::ExecutionEngine;
 
    constexpr bool asBoolean() const { return d.getBool(); }
    constexpr int asInteger() const { return d.getInt(); }
    constexpr double asDouble() const { return d.getDouble(); }
    QString asString() const { return d.getString(); }
 
    constexpr bool parsedEquals(const QJSPrimitiveValue &other) const
    {
        return type() != Undefined && equals(other);
    }
 
    static QJSPrimitiveValue numberFromString(const QString &string)
    {
        bool ok;
        const int intValue = string.toInt(&ok);
        if (ok)
            return intValue;
 
        const double doubleValue = string.toDouble(&ok);
        if (ok)
            return doubleValue;
        if (string.isEmpty())
            return 0;
        if (string == QStringLiteral("Infinity"))
            return std::numeric_limits<double>::infinity();
        if (string == QStringLiteral("-Infinity"))
            return -std::numeric_limits<double>::infinity();
        if (string == QStringLiteral("NaN"))
            return std::numeric_limits<double>::quiet_NaN();
        return QJSPrimitiveUndefined();
    }
 
    static Q_QML_EXPORT QString toString(double d);
 
    template<typename Operators, typename Lhs, typename Rhs>
    static QJSPrimitiveValue operateOnIntegers(const QJSPrimitiveValue &lhs,
                                               const QJSPrimitiveValue &rhs)
    {
        int result;
        if (Operators::opOverflow(lhs.d.get<Lhs>(), rhs.d.get<Rhs>(), &result))
            return Operators::op(lhs.d.get<Lhs>(), rhs.d.get<Rhs>());
        return result;
    }
 
    template<typename Operators>
    static QJSPrimitiveValue operate(const QJSPrimitiveValue &lhs, const QJSPrimitiveValue &rhs)
    {
        switch (lhs.type()) {
        case Undefined:
            switch (rhs.type()) {
            case Undefined: return std::numeric_limits<double>::quiet_NaN();
            case Null:      return std::numeric_limits<double>::quiet_NaN();
            case Boolean:   return std::numeric_limits<double>::quiet_NaN();
            case Integer:   return std::numeric_limits<double>::quiet_NaN();
            case Double:    return std::numeric_limits<double>::quiet_NaN();
            case String:    return Operators::op(QJSPrimitiveUndefined(), rhs.asString());
            }
            break;
        case Null:
            switch (rhs.type()) {
            case Undefined: return std::numeric_limits<double>::quiet_NaN();
            case Null:      return operateOnIntegers<Operators, int, int>(0, 0);
            case Boolean:   return operateOnIntegers<Operators, int, bool>(0, rhs);
            case Integer:   return operateOnIntegers<Operators, int, int>(0, rhs);
            case Double:    return Operators::op(0, rhs.asDouble());
            case String:    return Operators::op(QJSPrimitiveNull(), rhs.asString());
            }
            break;
        case Boolean:
            switch (rhs.type()) {
            case Undefined: return std::numeric_limits<double>::quiet_NaN();
            case Null:      return operateOnIntegers<Operators, bool, int>(lhs, 0);
            case Boolean:   return operateOnIntegers<Operators, bool, bool>(lhs, rhs);
            case Integer:   return operateOnIntegers<Operators, bool, int>(lhs, rhs);
            case Double:    return Operators::op(lhs.asBoolean(), rhs.asDouble());
            case String:    return Operators::op(lhs.asBoolean(), rhs.asString());
            }
            break;
        case Integer:
            switch (rhs.type()) {
            case Undefined: return std::numeric_limits<double>::quiet_NaN();
            case Null:      return operateOnIntegers<Operators, int, int>(lhs, 0);
            case Boolean:   return operateOnIntegers<Operators, int, bool>(lhs, rhs);
            case Integer:   return operateOnIntegers<Operators, int, int>(lhs, rhs);
            case Double:    return Operators::op(lhs.asInteger(), rhs.asDouble());
            case String:    return Operators::op(lhs.asInteger(), rhs.asString());
            }
            break;
        case Double:
            switch (rhs.type()) {
            case Undefined: return std::numeric_limits<double>::quiet_NaN();
            case Null:      return Operators::op(lhs.asDouble(), 0);
            case Boolean:   return Operators::op(lhs.asDouble(), rhs.asBoolean());
            case Integer:   return Operators::op(lhs.asDouble(), rhs.asInteger());
            case Double:    return Operators::op(lhs.asDouble(), rhs.asDouble());
            case String:    return Operators::op(lhs.asDouble(), rhs.asString());
            }
            break;
        case String:
            switch (rhs.type()) {
            case Undefined: return Operators::op(lhs.asString(), QJSPrimitiveUndefined());
            case Null:      return Operators::op(lhs.asString(), QJSPrimitiveNull());
            case Boolean:   return Operators::op(lhs.asString(), rhs.asBoolean());
            case Integer:   return Operators::op(lhs.asString(), rhs.asInteger());
            case Double:    return Operators::op(lhs.asString(), rhs.asDouble());
            case String:    return Operators::op(lhs.asString(), rhs.asString());
            }
            break;
        }
 
        Q_UNREACHABLE_RETURN(QJSPrimitiveUndefined());
    }
 
    constexpr bool isNanOrUndefined() const
    {
        switch (type()) {
        case Undefined: return true;
        case Null:      return false;
        case Boolean:   return false;
        case Integer:   return false;
        case Double:    return std::isnan(asDouble());
        case String:    return false;
        }
        // GCC 8.x does not treat __builtin_unreachable() as constexpr
    #if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900)
        Q_UNREACHABLE_RETURN(false);
    #else
        return false;
    #endif
    }
 
    struct QJSPrimitiveValuePrivate
    {
        // Can't be default because QString has a non-trivial ctor.
        constexpr QJSPrimitiveValuePrivate() noexcept {}
 
        Q_IMPLICIT constexpr QJSPrimitiveValuePrivate(QJSPrimitiveUndefined) noexcept  {}
        Q_IMPLICIT constexpr QJSPrimitiveValuePrivate(QJSPrimitiveNull) noexcept
            : m_type(Null) {}
        Q_IMPLICIT constexpr QJSPrimitiveValuePrivate(bool b) noexcept
            : m_bool(b), m_type(Boolean) {}
        Q_IMPLICIT constexpr QJSPrimitiveValuePrivate(int i) noexcept
            : m_int(i), m_type(Integer) {}
        Q_IMPLICIT constexpr QJSPrimitiveValuePrivate(double d) noexcept
            : m_double(d), m_type(Double) {}
        Q_IMPLICIT QJSPrimitiveValuePrivate(QString s) noexcept
            : m_string(std::move(s)), m_type(String) {}
 
        constexpr QJSPrimitiveValuePrivate(const QJSPrimitiveValuePrivate &other) noexcept
            : m_type(other.m_type)
        {
            // Not copy-and-swap since swap() would be much more complicated.
            if (!assignSimple(other))
                new (&m_string) QString(other.m_string);
        }
 
        constexpr QJSPrimitiveValuePrivate(QJSPrimitiveValuePrivate &&other) noexcept
            : m_type(other.m_type)
        {
            // Not move-and-swap since swap() would be much more complicated.
            if (!assignSimple(other))
                new (&m_string) QString(std::move(other.m_string));
        }
 
        constexpr QJSPrimitiveValuePrivate &operator=(const QJSPrimitiveValuePrivate &other) noexcept
        {
            if (this == &other)
                return *this;
 
            if (m_type == String) {
                if (other.m_type == String) {
                    m_type = other.m_type;
                    m_string = other.m_string;
                    return *this;
                }
                m_string.~QString();
            }
 
            m_type = other.m_type;
            if (!assignSimple(other))
                new (&m_string) QString(other.m_string);
            return *this;
        }
 
        constexpr QJSPrimitiveValuePrivate &operator=(QJSPrimitiveValuePrivate &&other) noexcept
        {
            if (this == &other)
                return *this;
 
            if (m_type == String) {
                if (other.m_type == String) {
                    m_type = other.m_type;
                    m_string = std::move(other.m_string);
                    return *this;
                }
                m_string.~QString();
            }
 
            m_type = other.m_type;
            if (!assignSimple(other))
                new (&m_string) QString(std::move(other.m_string));
            return *this;
        }
 
        ~QJSPrimitiveValuePrivate()
        {
            if (m_type == String)
                m_string.~QString();
        }
 
        constexpr Type type() const noexcept { return m_type; }
        constexpr bool getBool() const noexcept { return m_bool; }
        constexpr int getInt() const noexcept { return m_int; }
        constexpr double getDouble() const noexcept { return m_double; }
        QString getString() const noexcept { return m_string; }
 
        template<typename T>
        constexpr T get() const noexcept {
            if constexpr (std::is_same_v<T, QJSPrimitiveUndefined>)
                return QJSPrimitiveUndefined();
            else if constexpr (std::is_same_v<T, QJSPrimitiveNull>)
                return QJSPrimitiveNull();
            else if constexpr (std::is_same_v<T, bool>)
                return getBool();
            else if constexpr (std::is_same_v<T, int>)
                return getInt();
            else if constexpr (std::is_same_v<T, double>)
                return getDouble();
            else if constexpr (std::is_same_v<T, QString>)
                return getString();
 
            // GCC 8.x does not treat __builtin_unreachable() as constexpr
        #if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900)
            Q_UNREACHABLE_RETURN(T());
        #else
            return T();
        #endif
        }
 
        constexpr QMetaType metaType() const noexcept {
            switch (m_type) {
            case Undefined:
                return QMetaType();
            case Null:
                return QMetaType::fromType<std::nullptr_t>();
            case Boolean:
                return QMetaType::fromType<bool>();
            case Integer:
                return QMetaType::fromType<int>();
            case Double:
                return QMetaType::fromType<double>();
            case String:
                return QMetaType::fromType<QString>();
            }
 
            // GCC 8.x does not treat __builtin_unreachable() as constexpr
        #if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900)
            Q_UNREACHABLE_RETURN(QMetaType());
        #else
            return QMetaType();
        #endif
        }
 
        constexpr void *data() noexcept {
            switch (m_type) {
            case Undefined:
            case Null:
                return nullptr;
            case Boolean:
                return &m_bool;
            case Integer:
                return &m_int;
            case Double:
                return &m_double;
            case String:
                return &m_string;
            }
 
            // GCC 8.x does not treat __builtin_unreachable() as constexpr
        #if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900)
            Q_UNREACHABLE_RETURN(nullptr);
        #else
            return nullptr;
        #endif
        }
 
        constexpr const void *data() const noexcept {
            switch (m_type) {
            case Undefined:
            case Null:
                return nullptr;
            case Boolean:
                return &m_bool;
            case Integer:
                return &m_int;
            case Double:
                return &m_double;
            case String:
                return &m_string;
            }
 
            // GCC 8.x does not treat __builtin_unreachable() as constexpr
        #if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900)
            Q_UNREACHABLE_RETURN(nullptr);
        #else
            return nullptr;
        #endif
        }
 
    private:
        constexpr bool assignSimple(const QJSPrimitiveValuePrivate &other) noexcept
        {
            switch (other.m_type) {
            case Undefined:
            case Null:
                return true;
            case Boolean:
                m_bool = other.m_bool;
                return true;
            case Integer:
                m_int = other.m_int;
                return true;
            case Double:
                m_double = other.m_double;
                return true;
            case String:
                return false;
            }
 
            // GCC 8.x does not treat __builtin_unreachable() as constexpr
        #if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900)
            Q_UNREACHABLE_RETURN(false);
        #else
            return false;
        #endif
        }
 
        union {
            bool m_bool;
            int m_int;
            double m_double;
            QString m_string;
 
            // Dummy value to trigger initialization of the whole storage.
            // We don't want to see maybe-uninitialized warnings every time we access m_string.
            std::byte m_zeroInitialize[sizeof(QString)] = {};
        };
 
        Type m_type = Undefined;
    };
 
    QJSPrimitiveValuePrivate d;
};
 
namespace QQmlPrivate {
    // TODO: Make this constexpr once std::isnan is constexpr.
    inline double jsExponentiate(double base, double exponent)
    {
        constexpr double qNaN = std::numeric_limits<double>::quiet_NaN();
        constexpr double inf = std::numeric_limits<double>::infinity();
 
        if (qIsNull(exponent))
            return 1.0;
 
        if (std::isnan(exponent))
            return qNaN;
 
        if (QJSNumberCoercion::equals(base, 1.0) || QJSNumberCoercion::equals(base, -1.0))
            return std::isinf(exponent) ? qNaN : std::pow(base, exponent);
 
        if (!qIsNull(base))
            return std::pow(base, exponent);
 
        if (std::copysign(1.0, base) > 0.0)
            return exponent < 0.0 ? inf : std::pow(base, exponent);
 
        if (exponent < 0.0)
            return QJSNumberCoercion::equals(std::fmod(-exponent, 2.0), 1.0) ? -inf : inf;
 
        return QJSNumberCoercion::equals(std::fmod(exponent, 2.0), 1.0)
                ? std::copysign(0, -1.0)
                : 0.0;
    }
}
 
QT_END_NAMESPACE
 
#endif // QJSPRIMITIVEVALUE_H