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[] = {{Kind::Add, "add"},           {Kind::Begin, "begin"},
                                              {Kind::BitAnd, "&"},          {Kind::BitOr, "|"},
                                              {Kind::BitXor, "^"},          {Kind::Call, "call"},
                                              {Kind::Cast, "cast"},         {Kind::CustomAssign, "="},
                                              {Kind::DecrPostfix, "--"},    {Kind::DecrPrefix, "--"},
                                              {Kind::Delete, "delete"},     {Kind::Deref, "*"},
                                              {Kind::Division, "/"},        {Kind::DivisionAssign, "/="},
                                              {Kind::Equal, "=="},          {Kind::End, "end"},
                                              {Kind::Greater, ">"},         {Kind::GreaterEqual, ">="},
                                              {Kind::HasMember, "?."},      {Kind::In, "in"},
                                              {Kind::IncrPostfix, "++"},    {Kind::IncrPrefix, "++"},
                                              {Kind::Index, "index"},       {Kind::IndexAssign, "index_assign"},
                                              {Kind::Lower, "<"},           {Kind::LowerEqual, "<="},
                                              {Kind::Member, "."},          {Kind::MemberCall, "method call"},
                                              {Kind::Negate, "~"},          {Kind::New, "new"},
                                              {Kind::Difference, "-"},      {Kind::DifferenceAssign, "-="},
                                              {Kind::Modulo, "%"},          {Kind::Multiple, "*"},
                                              {Kind::MultipleAssign, "*="}, {Kind::Sum, "+"},
                                              {Kind::Pack, "unpack"},       {Kind::Unset, "unset"},
                                              {Kind::SumAssign, "+="},      {Kind::Power, "**"},
                                              {Kind::ShiftLeft, "<<"},      {Kind::ShiftRight, ">>"},
                                              {Kind::SignNeg, "-"},         {Kind::SignPos, "+"},
                                              {Kind::Size, "size"},         {Kind::TryMember, ".?"},
                                              {Kind::Unequal, "!="},        {Kind::Unknown, "<unknown>"},
                                              {Kind::Unpack, "unpack"},     {Kind::Unset, "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