coercer.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <string>
#include <utility>
 
#include <hilti/rt/3rdparty/ArticleEnumClass-v2/EnumClass.h>
 
#include <hilti/ast/ctor.h>
#include <hilti/ast/expression.h>
#include <hilti/ast/operator.h>
#include <hilti/ast/type.h>
#include <hilti/base/util.h>
 
namespace hilti {
 
enum class CoercionStyle {
    Assignment = (1U << 0U),
 
    FunctionCall = (1U << 2U),
 
    TryExactMatch = (1U << 3U),
 
    TryConstPromotion = (1U << 4U),
 
    TryCoercion = (1U << 5U),
 
    TryCoercionWithinSameType = (1U << 6U),
 
    DisallowTypeChanges = (1U << 7U),
 
    ContextualConversion = (1U << 8U),
 
    TryDeref = (1U << 9U),
 
    TryAllForAssignment = Assignment | TryExactMatch | TryConstPromotion | TryCoercion | TryDeref,
 
    TryDirectForMatching = TryExactMatch | TryConstPromotion,
 
    TryAllForMatching = TryDirectForMatching | TryCoercion,
 
    TryDirectMatchForFunctionCall = FunctionCall | TryExactMatch | TryConstPromotion,
 
    TryAllForFunctionCall = TryDirectMatchForFunctionCall | TryCoercion | TryDeref,
};
 
extern std::string to_string(bitmask<CoercionStyle> style);
 
} // namespace hilti
 
enableEnumClassBitmask(hilti::CoercionStyle); // Must be in global scope
 
namespace hilti {
 
struct CoercedExpression {
    operator bool() const { return coerced.hasValue(); }
 
    Result<Expression*> coerced;
 
    Expression* nexpr = {};
 
    bool consider_type_changed = false;
 
    CoercedExpression(Expression* src) : coerced(src) {}
 
    CoercedExpression(QualifiedType* src, Expression* coerced)
        : coerced(coerced),
          nexpr(coerced),
          consider_type_changed(src->type()->typeClass() != coerced->type()->type()->typeClass()) {}
 
    CoercedExpression() = default;
 
    CoercedExpression(const result::Error& error) : coerced(error) {}
};
 
CoercedExpression coerceExpression(Builder* builder,
                                   Expression* e,
                                   QualifiedType* dst,
                                   bitmask<CoercionStyle> style = CoercionStyle::TryAllForAssignment,
                                   bool lhs = false);
 
CoercedExpression coerceExpression(Builder* builder,
                                   Expression* e,
                                   QualifiedType* src_,
                                   QualifiedType* dst_,
                                   bitmask<CoercionStyle> style = CoercionStyle::TryAllForAssignment,
                                   bool lhs = false);
 
Result<std::pair<bool, Expressions>> coerceOperands(Builder* builder,
                                                    operator_::Kind kind,
                                                    const Expressions& exprs,
                                                    const operator_::Operands& operands,
                                                    bitmask<CoercionStyle> style);
 
Result<Ctor*> coerceCtor(Builder* builder,
                         Ctor* c,
                         QualifiedType* dst,
                         bitmask<CoercionStyle> style = CoercionStyle::TryAllForAssignment);
 
Result<QualifiedType*> coerceType(Builder* builder,
                                  QualifiedType* src_,
                                  QualifiedType* dst_,
                                  bitmask<CoercionStyle> style = CoercionStyle::TryAllForAssignment);
 
namespace coercer::detail {
 
Ctor* coerceCtor(Builder* builder, Ctor* c, QualifiedType* dst, bitmask<CoercionStyle> style);
 
QualifiedType* coerceType(Builder* builder, QualifiedType* t, QualifiedType* dst, bitmask<CoercionStyle> style);
 
} // namespace coercer::detail
 
} // namespace hilti