operator.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <string>
#include <utility>
 
#include <hilti/ast/forward.h>
#include <hilti/ast/node.h>
#include <hilti/ast/types/operand-list.h>
#include <hilti/base/logger.h>
 
namespace hilti {
 
namespace expression {
class ResolvedOperator;
}
 
namespace operator_ {
class Registry;
 
enum class Kind {
    Add,
    Begin,
    BitAnd,
    BitOr,
    BitXor,
    Call,
    Cast,
    CustomAssign,
    DecrPostfix,
    DecrPrefix,
    Delete,
    Deref,
    Difference,
    DifferenceAssign,
    Division,
    DivisionAssign,
    Equal,
    End,
    Greater,
    GreaterEqual,
    HasMember,
    In,
    IncrPostfix,
    IncrPrefix,
    Index,
    IndexAssign,
    Lower,
    LowerEqual,
    Member,
    MemberCall,
    Modulo,
    Multiple,
    MultipleAssign,
    Negate,
    New,
    Pack,
    Power,
    ShiftLeft,
    ShiftRight,
    SignNeg,
    SignPos,
    Size,
    Sum,
    SumAssign,
    TryMember,
    Unequal,
    Unknown,
    Unpack,
    Unset
};
 
inline auto isCommutative(Kind k) {
    switch ( k ) {
        case Kind::BitAnd:
        case Kind::BitOr:
        case Kind::BitXor:
        case Kind::Equal:
        case Kind::Unequal:
        case Kind::Multiple:
        case Kind::Sum: return true;
 
        case Kind::Add:
        case Kind::Begin:
        case Kind::Call:
        case Kind::Cast:
        case Kind::CustomAssign:
        case Kind::DecrPostfix:
        case Kind::DecrPrefix:
        case Kind::Delete:
        case Kind::Deref:
        case Kind::Difference:
        case Kind::DifferenceAssign:
        case Kind::Division:
        case Kind::DivisionAssign:
        case Kind::End:
        case Kind::Greater:
        case Kind::GreaterEqual:
        case Kind::HasMember:
        case Kind::In:
        case Kind::IncrPostfix:
        case Kind::IncrPrefix:
        case Kind::Index:
        case Kind::IndexAssign:
        case Kind::Lower:
        case Kind::LowerEqual:
        case Kind::Member:
        case Kind::MemberCall:
        case Kind::Modulo:
        case Kind::MultipleAssign:
        case Kind::Negate:
        case Kind::New:
        case Kind::Pack:
        case Kind::Power:
        case Kind::ShiftLeft:
        case Kind::ShiftRight:
        case Kind::SignNeg:
        case Kind::SignPos:
        case Kind::Size:
        case Kind::SumAssign:
        case Kind::TryMember:
        case Kind::Unknown:
        case Kind::Unpack:
        case Kind::Unset: return false;
    };
 
    util::cannotBeReached();
}
 
namespace detail {
constexpr util::enum_::Value<Kind> Kinds[] =
    {{.value = Kind::Add, .name = "add"},           {.value = Kind::Begin, .name = "begin"},
     {.value = Kind::BitAnd, .name = "&"},          {.value = Kind::BitOr, .name = "|"},
     {.value = Kind::BitXor, .name = "^"},          {.value = Kind::Call, .name = "call"},
     {.value = Kind::Cast, .name = "cast"},         {.value = Kind::CustomAssign, .name = "="},
     {.value = Kind::DecrPostfix, .name = "--"},    {.value = Kind::DecrPrefix, .name = "--"},
     {.value = Kind::Delete, .name = "delete"},     {.value = Kind::Deref, .name = "*"},
     {.value = Kind::Division, .name = "/"},        {.value = Kind::DivisionAssign, .name = "/="},
     {.value = Kind::Equal, .name = "=="},          {.value = Kind::End, .name = "end"},
     {.value = Kind::Greater, .name = ">"},         {.value = Kind::GreaterEqual, .name = ">="},
     {.value = Kind::HasMember, .name = "?."},      {.value = Kind::In, .name = "in"},
     {.value = Kind::IncrPostfix, .name = "++"},    {.value = Kind::IncrPrefix, .name = "++"},
     {.value = Kind::Index, .name = "index"},       {.value = Kind::IndexAssign, .name = "index_assign"},
     {.value = Kind::Lower, .name = "<"},           {.value = Kind::LowerEqual, .name = "<="},
     {.value = Kind::Member, .name = "."},          {.value = Kind::MemberCall, .name = "method call"},
     {.value = Kind::Negate, .name = "~"},          {.value = Kind::New, .name = "new"},
     {.value = Kind::Difference, .name = "-"},      {.value = Kind::DifferenceAssign, .name = "-="},
     {.value = Kind::Modulo, .name = "%"},          {.value = Kind::Multiple, .name = "*"},
     {.value = Kind::MultipleAssign, .name = "*="}, {.value = Kind::Sum, .name = "+"},
     {.value = Kind::Pack, .name = "pack"},         {.value = Kind::Unset, .name = "unset"},
     {.value = Kind::SumAssign, .name = "+="},      {.value = Kind::Power, .name = "**"},
     {.value = Kind::ShiftLeft, .name = "<<"},      {.value = Kind::ShiftRight, .name = ">>"},
     {.value = Kind::SignNeg, .name = "-"},         {.value = Kind::SignPos, .name = "+"},
     {.value = Kind::Size, .name = "size"},         {.value = Kind::TryMember, .name = ".?"},
     {.value = Kind::Unequal, .name = "!="},        {.value = Kind::Unknown, .name = "<unknown>"},
     {.value = Kind::Unpack, .name = "unpack"},     {.value = Kind::Unset, .name = "unset"}};
 
extern std::string print(Kind kind, const Expressions& operands);
 
 
extern std::string printSignature(Kind kind, const Expressions& operands, const Meta& meta);
 
} // namespace detail
 
constexpr auto to_string(Kind m) { return util::enum_::to_string(m, detail::Kinds); }
 
enum class Priority { Low, Normal };
 
using Operand = type::operand_list::Operand;
using Operands = type::operand_list::Operands;
 
struct Signature {
    struct QType {
        parameter::Kind kind = parameter::Kind::Unknown; 
        UnqualifiedType* type = nullptr;                 
        std::string doc;                                 
        UnqualifiedType* external_type = nullptr;        
        UnqualifiedType* getType() const {
            if ( external_type )
                return external_type;
            else
                return type;
        }
 
        operator bool() const { return kind != parameter::Kind::Unknown && getType(); }
    };
 
    struct QResult {
        Constness constness = Constness::Const; 
        UnqualifiedType* type = nullptr;        
        std::string doc;                        
        operator bool() const { return type != nullptr; }
    };
 
    struct QParam {
        std::string name;               
        QType type;                     
        Expression* default_ = nullptr; 
        bool optional = false;          
        operator bool() const { return type; }
    };
 
    operator_::Kind kind;
    operator_::Priority priority = operator_::Priority::Normal;
 
    QType self;
    QType op0;
    QType op1;
    QType op2;
 
    std::optional<std::string> member;
    QParam param0;
    QParam param1;
    QParam param2;
    QParam param3;
    QParam param4;
 
    QResult result;         
    std::string result_doc; 
    std::string ns;        
    std::string doc;       
    bool skip_doc = false; 
};
 
namespace detail {
 
struct ProcessedSignature {
    operator_::Kind kind = operator_::Kind::Unknown;
    node::RetainedPtr<QualifiedType>
        result; 
    node::RetainedPtr<type::OperandList> operands; 
    operator_::Priority priority;
    std::string doc;        
    std::string result_doc; 
    std::string namespace_; 
    bool skip_doc;          
};
} // namespace detail
 
} // namespace operator_
 
class Operator {
public:
    template<typename T>
    using Result = ::hilti::Result<T>;
 
    Operator(Meta meta = Meta(), bool builtin = true) : _meta(std::move(meta)), _builtin(builtin) {}
 
    virtual ~Operator() {}
 
    Operator(const Operator& other) = delete;
    Operator(Operator&& other) = delete;
 
    Operator& operator=(const Operator& other) = delete;
    Operator& operator=(Operator&& other) = delete;
 
    auto isInitialized() const { return _signature.has_value(); }
 
    auto hasOperands() const { return _signature->operands; }
 
    const auto& signature() const {
        assert(_signature);
        return *_signature;
    }
 
    auto kind() const { return signature().kind; }
 
    auto isBuiltIn() const { return _builtin; }
 
    auto operands() const { return signature().operands->operands(); }
 
    auto op0() const { return operands()[0]; }
 
    auto op1() const { return operands()[1]; }
 
    auto op2() const { return operands()[2]; }
 
    const auto& meta() const { return _meta; }
 
    const auto& doc() const { return signature().doc; }
 
    auto typename_() const { return _typename(); }
 
    virtual QualifiedType* result(Builder* builder, const Expressions& operands, const Meta& meta) const;
 
    virtual std::optional<operator_::Operands> filter(Builder* builder, const Expressions& operands) const {
        return {};
    }
 
    virtual void validate(expression::ResolvedOperator* n) const {};
 
    virtual Result<expression::ResolvedOperator*> instantiate(Builder* builder, Expressions operands,
                                                              Meta meta) const = 0;
 
    virtual std::string name() const = 0;
 
    virtual std::string print() const;
 
    virtual std::string dump() const;
 
protected:
    friend class operator_::Registry;
 
    bool init(Builder* builder, Node* scope_root = nullptr);
 
    virtual operator_::Signature signature(Builder* builder) const = 0;
 
    virtual std::string _typename() const { return util::typename_(*this); }
 
    static operator_::Operand* operandForType(Builder* builder, parameter::Kind kind, UnqualifiedType* t,
                                              std::string doc = "");
 
    static operator_::Operand* operandForExpression(Builder* builder, parameter::Kind kind, const Expressions& e,
                                                    size_t i) {
        return operandForType(builder, kind, e[i]->type()->type(), "");
    }
 
private:
    Meta _meta;
    bool _builtin;
    std::optional<operator_::detail::ProcessedSignature> _signature;
};
 
class BuiltInMemberCall : public Operator {
public:
    ~BuiltInMemberCall() override {}
 
    std::string print() const final;
};
 
} // namespace hilti