rego.hh

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "rego_c.h"
 
#include <trieste/trieste.h>
 
namespace rego
{
  using namespace trieste;
  using namespace wf::ops;
 
  inline const auto Module = TokenDef("rego-module", flag::symtab);
  inline const auto Package = TokenDef("rego-package");
  inline const auto Policy = TokenDef("rego-policy");
  inline const auto Rule = TokenDef("rego-rule", flag::symtab);
  inline const auto RuleHead = TokenDef("rego-rulehead");
  inline const auto RuleHeadComp = TokenDef("rego-ruleheadcomp");
  inline const auto RuleHeadFunc = TokenDef("rego-ruleheadfunc");
  inline const auto RuleHeadSet = TokenDef("rego-ruleheadset");
  inline const auto RuleHeadObj = TokenDef("rego-ruleheadobj");
  inline const auto RuleArgs = TokenDef("rego-ruleargs");
  inline const auto Query = TokenDef("rego-query");
  inline const auto Literal = TokenDef("rego-literal");
  inline const auto Expr = TokenDef("rego-expr");
  inline const auto ExprInfix = TokenDef("rego-exprinfix");
  inline const auto ExprCall = TokenDef("rego-exprcall");
  inline const auto ExprEvery = TokenDef("rego-exprevery");
  inline const auto ExprParens = TokenDef("rego-exprparens");
  inline const auto UnaryExpr = TokenDef("rego-unaryexpr");
  inline const auto NotExpr = TokenDef("rego-not-expr");
  inline const auto Term = TokenDef("rego-term");
  inline const auto InfixOperator = TokenDef("rego-infixoperator");
  inline const auto BoolOperator = TokenDef("rego-booloperator");
  inline const auto ArithOperator = TokenDef("rego-arithoperator");
  inline const auto AssignOperator = TokenDef("rego-assignoperator");
  inline const auto BinOperator = TokenDef("rego-binoperator");
  inline const auto Ref = TokenDef("rego-ref");
  inline const auto RefArgBrack = TokenDef("rego-refargbrack");
  inline const auto RefArgDot = TokenDef("rego-refargdot");
  inline const auto Var = TokenDef("rego-var", flag::print);
  inline const auto Scalar = TokenDef("rego-scalar");
  inline const auto String = TokenDef("rego-string");
  inline const auto Array = TokenDef("rego-array");
  inline const auto Object = TokenDef("rego-object");
  inline const auto Set = TokenDef("rego-set");
  inline const auto ObjectItem = TokenDef("rego-objectitem");
  inline const auto RawString = TokenDef("rego-rawstring", flag::print);
  inline const auto JSONString = TokenDef("rego-STRING", flag::print);
  inline const auto Int = TokenDef("rego-INT", flag::print);
  inline const auto Float = TokenDef("rego-FLOAT", flag::print);
  inline const auto True = TokenDef("rego-true");
  inline const auto False = TokenDef("rego-false");
  inline const auto Null = TokenDef("rego-null");
  inline const auto Equals = TokenDef("rego-equals");
  inline const auto NotEquals = TokenDef("rego-notequals");
  inline const auto LessThan = TokenDef("rego-lessthan");
  inline const auto GreaterThan = TokenDef("rego-greaterthan");
  inline const auto LessThanOrEquals = TokenDef("rego-lessthanorequals");
  inline const auto GreaterThanOrEquals = TokenDef("rego-greaterthanorequals");
  inline const auto Add = TokenDef("rego-add");
  inline const auto Subtract = TokenDef("rego-subtract");
  inline const auto Multiply = TokenDef("rego-multiply");
  inline const auto Divide = TokenDef("rego-divide");
  inline const auto Modulo = TokenDef("rego-modulo");
  inline const auto And = TokenDef("rego-and");
  inline const auto Or = TokenDef("rego-or");
  inline const auto Assign = TokenDef("rego-assign");
  inline const auto Unify = TokenDef("rego-unify");
  inline const auto Default = TokenDef("rego-default");
  inline const auto Some = TokenDef("rego-some");
  inline const auto SomeDecl = TokenDef("rego-somedecl");
  inline const auto If = TokenDef("rego-if");
  inline const auto IsIn = TokenDef("rego-in");
  inline const auto Contains = TokenDef("rego-contains");
  inline const auto Else = TokenDef("rego-else");
  inline const auto As = TokenDef("rego-as");
  inline const auto With = TokenDef("rego-with");
  inline const auto Every = TokenDef("rego-every");
  inline const auto ArrayCompr = TokenDef("rego-arraycompr");
  inline const auto ObjectCompr = TokenDef("rego-objectcompr");
  inline const auto SetCompr = TokenDef("rego-setcompr");
  inline const auto Membership = TokenDef("rego-membership");
  inline const auto Not = TokenDef("rego-not");
  inline const auto Import =
    TokenDef("rego-import", flag::lookdown | flag::lookup | flag::shadowing);
  inline const auto Placeholder = TokenDef("rego-placeholder");
  inline const auto Version = TokenDef("rego-version", flag::print);
 
  // intermediate tokens
  inline const auto RuleBodySeq = TokenDef("rego-rulebodyseq");
  inline const auto ImportSeq = TokenDef("rego-importseq");
  inline const auto RuleRef = TokenDef("rego-ruleref");
  inline const auto RuleHeadType = TokenDef("rego-ruleheadtype");
  inline const auto WithSeq = TokenDef("rego-withseq");
  inline const auto TermSeq = TokenDef("rego-termseq");
  inline const auto ExprSeq = TokenDef("rego-exprseq");
  inline const auto VarSeq = TokenDef("rego-varseq");
  inline const auto RefHead = TokenDef("rego-refhead");
  inline const auto RefArgSeq = TokenDef("rego-refargseq");
  inline const auto Key = TokenDef("rego-key", flag::print);
  inline const auto Val = TokenDef("rego-value");
  inline const auto Undefined = TokenDef("rego-undefined");
 
  // other tokens
  inline const auto Results = TokenDef("rego-results", flag::symtab);
  inline const auto Result = TokenDef("rego-result", flag::symtab);
  inline const auto Bindings = TokenDef("rego-bindings");
  inline const auto Terms = TokenDef("rego-terms");
  inline const auto Binding = TokenDef("rego-binding", flag::lookdown);
  inline const auto ErrorCode = TokenDef("rego-errorcode");
  inline const auto ErrorSeq = TokenDef("rego-errorseq");
 
  inline const auto wf_assign_op = Assign | Unify;
  inline const auto wf_arith_op = Add | Subtract | Multiply | Divide | Modulo;
  inline const auto wf_bin_op = And | Or | Subtract;
  inline const auto wf_bool_op = Equals | NotEquals | LessThan |
    LessThanOrEquals | GreaterThan | GreaterThanOrEquals | Not;
  inline const auto wf_exprs =
    Term | ExprCall | ExprInfix | ExprEvery | ExprParens | UnaryExpr;
 
  // clang-format off
  inline const auto wf =
      (Top <<= Query | Module)
    | (Module <<= Package * Version * ImportSeq * Policy)
    | (ImportSeq <<= Import++)
    | (Import <<= Ref * Var)
    | (Package <<= Ref)
    | (Policy <<= Rule++)
    | (Rule <<= (Default >>= True | False) * RuleHead * RuleBodySeq)
    | (RuleHead <<= RuleRef * (RuleHeadType >>= (RuleHeadSet | RuleHeadObj | RuleHeadFunc | RuleHeadComp)))
    | (RuleRef <<= Var | Ref)
    | (RuleHeadComp <<= Expr)
    | (RuleHeadObj <<= Expr * Expr)
    | (RuleHeadFunc <<= RuleArgs * Expr)
    | (RuleHeadSet <<= Expr)
    | (RuleArgs <<= Term++)
    | (RuleBodySeq <<= (Else | Query)++)
    | (Else <<= Expr * Query)
    | (Query <<= Literal++)
    | (Literal <<= (Expr >>= SomeDecl | Expr | NotExpr) * WithSeq)
    | (WithSeq <<= With++)
    | (With <<= Term * Expr)
    | (SomeDecl <<= ExprSeq * (IsIn >>= Expr | Undefined))
    | (NotExpr <<= Expr)
    | (Expr <<= (Term | ExprCall | ExprInfix | ExprEvery | ExprParens | UnaryExpr))
    | (ExprCall <<= Ref * ExprSeq)
    | (ExprSeq <<= Expr++)
    | (ExprInfix <<= Expr * InfixOperator * Expr)
    | (ExprEvery <<= VarSeq * (IsIn >>= Term | ExprCall | ExprInfix) * Query)
    | (VarSeq <<= Var++[1])
    | (ExprParens <<= Expr)
    | (UnaryExpr <<= Expr)
    | (Membership <<= ExprSeq * Expr)
    | (Term <<= Ref | Var | Scalar | Array | Object | Set | Membership | ArrayCompr | ObjectCompr | SetCompr)
    | (ArrayCompr <<= Expr * Query)
    | (SetCompr <<= Expr * Query)
    | (ObjectCompr <<= Expr * Expr * Query)
    | (InfixOperator <<= AssignOperator | BoolOperator | ArithOperator | BinOperator)
    | (BoolOperator <<= Equals | NotEquals | LessThan | GreaterThan | LessThanOrEquals | GreaterThanOrEquals)
    | (ArithOperator <<= Add | Subtract | Multiply | Divide | Modulo)
    | (BinOperator <<= And | Or)
    | (AssignOperator <<= Assign | Unify)
    | (Ref <<= RefHead * RefArgSeq)
    | (RefHead <<= Var | Array | Object | Set | ArrayCompr | ObjectCompr | SetCompr | ExprCall)
    | (RefArgSeq <<= (RefArgDot | RefArgBrack)++)
    | (RefArgBrack <<= Expr | Placeholder)
    | (RefArgDot <<= Var)
    | (Scalar <<= String | Int | Float | True | False | Null)
    | (String <<= JSONString | RawString)
    | (Array <<= Expr++)
    | (Object <<= ObjectItem++)
    | (ObjectItem <<= (Key >>= Expr) * (Val >>= Expr))
    | (Set <<= Expr++)
    ;
  // clang-format on
 
  // clang-format off
  inline const auto wf_result =
    (Top <<= Results | Undefined)
    | (Results <<= Result++[1])
    | (Result <<= Terms * Bindings)
    | (Terms <<= Term++)
    | (Bindings <<= Binding++)
    | (Binding <<= (Key >>= Var) * (Val >>= Term))[Key]
    | (Term <<= Scalar | Array | Object | Set)
    | (Array <<= Term++)
    | (Set <<= Term++)
    | (Object <<= ObjectItem++)
    | (ObjectItem <<= (Key >>= Term) * (Val >>= Term))
    | (Scalar <<= JSONString | Int | Float | True | False | Null)
    | (Error <<= ErrorMsg * ErrorAst * ErrorCode)
    ;
  // clang-format on
 
  struct BuiltInDef;
  using BuiltIn = std::shared_ptr<BuiltInDef>;
 
  using BuiltInBehavior = std::function<Node(const Nodes&)>;
 
  class BigInt
  {
  public:
    BigInt();
    BigInt(const Location& value);
    BigInt(std::int64_t value);
    BigInt(std::size_t value);
 
    const Location& loc() const;
    std::int64_t to_int() const;
    std::size_t to_size() const;
    bool is_negative() const;
    bool is_zero() const;
    BigInt increment() const;
    BigInt decrement() const;
 
    static bool is_int(const Location& loc);
 
    friend BigInt operator+(const BigInt& lhs, const BigInt& rhs);
    friend BigInt operator-(const BigInt& lhs, const BigInt& rhs);
    friend BigInt operator*(const BigInt& lhs, const BigInt& rhs);
    friend BigInt operator/(const BigInt& lhs, const BigInt& rhs);
    friend BigInt operator%(const BigInt& lhs, const BigInt& rhs);
 
    friend bool operator>(const BigInt& lhs, const BigInt& rhs);
    friend bool operator<(const BigInt& lhs, const BigInt& rhs);
    friend bool operator<=(const BigInt& lhs, const BigInt& rhs);
    friend bool operator>=(const BigInt& lhs, const BigInt& rhs);
    friend bool operator==(const BigInt& lhs, const BigInt& rhs);
    friend bool operator!=(const BigInt& lhs, const BigInt& rhs);
 
    friend std::ostream& operator<<(std::ostream& os, const BigInt& value);
 
    BigInt negate() const;
 
  private:
    struct DivideResult
    {
      std::string quotient;
      std::string remainder;
    };
 
    static bool less_than(
      const std::string_view& lhs, const std::string_view& rhs);
    static bool greater_than(
      const std::string_view& lhs, const std::string_view& rhs);
    static bool equal(const std::string_view& lhs, const std::string_view& rhs);
    static std::string add(
      const std::string_view& lhs, const std::string_view& rhs, bool negative);
    static std::string subtract(
      const std::string_view& lhs, const std::string_view& rhs, bool negative);
    static DivideResult divide(
      const std::string_view& lhs, const std::string_view& rhs);
    static std::string multiply(
      const std::string_view& lhs, const std::string_view& rhs);
    std::string_view digits() const;
    Location m_loc;
    static Location Zero;
    static Location One;
  };
 
  struct UnwrapResult
  {
    Node node;
 
    bool success;
  };
 
  class UnwrapOpt
  {
  public:
    UnwrapOpt(std::size_t index);
 
    bool exclude_got() const;
    UnwrapOpt& exclude_got(bool exclude_got);
 
    bool specify_number() const;
    UnwrapOpt& specify_number(bool specify_number);
 
    const std::string& code() const;
    UnwrapOpt& code(const std::string& value);
 
    const std::string& pre() const;
    UnwrapOpt& pre(const std::string& value);
 
    const std::string& message() const;
    UnwrapOpt& message(const std::string& value);
 
    const std::string& func() const;
    UnwrapOpt& func(const std::string& value);
 
    const std::vector<Token>& types() const;
    UnwrapOpt& types(const std::vector<Token>& value);
 
    const Token& type() const;
    UnwrapOpt& type(const Token& value);
 
    Node unwrap(const Nodes& args) const;
 
  private:
    bool m_exclude_got;
    bool m_specify_number;
    std::string m_code;
    std::string m_prefix;
    std::string m_message;
    std::string m_func;
    std::vector<Token> m_types;
    std::size_t m_index;
  };
 
  Node unwrap_arg(const Nodes& args, const UnwrapOpt& options);
 
  UnwrapResult unwrap(const Node& term, const Token& type);
 
  UnwrapResult unwrap(const Node& term, const std::set<Token>& types);
 
  BigInt get_int(const Node& node);
 
  double get_double(const Node& node);
 
  std::optional<BigInt> try_get_int(const Node& node);
 
  std::string get_string(const Node& node);
 
  bool get_bool(const Node& node);
 
  std::optional<Node> try_get_item(
    const Node& node, const std::string_view& key);
 
  Node scalar(BigInt value);
 
  Node scalar(double value);
 
  Node scalar(bool value);
 
  Node scalar(const char* value);
 
  Node scalar(const std::string& value);
 
  Node scalar();
 
  Node object_item(const Node& key_term, const Node& val_term);
 
  Node object(const Nodes& object_items);
 
  Node array(const Nodes& array_members);
 
  Node set(const Nodes& set_members);
 
  void set_tzdata_path(const std::filesystem::path& path);
 
  const std::size_t AnyArity = std::numeric_limits<std::size_t>::max();
 
  struct BuiltInDef
  {
    Location name;
    std::size_t arity;
 
    BuiltInBehavior behavior;
 
    BuiltInDef(Location name_, std::size_t arity_, BuiltInBehavior behavior_);
 
    virtual ~BuiltInDef() = default;
 
    virtual void clear();
 
    static BuiltIn create(
      const Location& name, std::size_t arity, BuiltInBehavior behavior);
  };
 
  class BuiltInsDef
  {
  public:
    BuiltInsDef() noexcept;
 
    bool is_builtin(const Location& name) const;
 
    bool is_deprecated(const Location& version, const Location& name) const;
 
    Node call(const Location& name, const Location& version, const Nodes& args);
 
    void clear();
 
    BuiltInsDef& register_builtin(const BuiltIn& built_in);
 
    const BuiltIn& at(const Location& name) const;
 
    bool strict_errors() const;
    BuiltInsDef& strict_errors(bool strict_errors);
 
    template <typename T>
    BuiltInsDef& register_builtins(const T& built_ins)
    {
      for (auto& built_in : built_ins)
      {
        register_builtin(built_in);
      }
 
      return *this;
    }
 
    BuiltInsDef& register_standard_builtins();
 
    static std::shared_ptr<BuiltInsDef> create();
 
    std::map<Location, BuiltIn>::const_iterator begin() const;
    std::map<Location, BuiltIn>::const_iterator end() const;
 
  private:
    std::map<Location, BuiltIn> m_builtins;
    bool m_strict_errors;
  };
 
  using BuiltIns = std::shared_ptr<BuiltInsDef>;
 
  const std::string UnknownError = "unknown_error";
  const std::string EvalTypeError = "eval_type_error";
  const std::string EvalBuiltInError = "eval_builtin_error";
  const std::string RegoTypeError = "rego_type_error";
  const std::string RegoParseError = "rego_parse_error";
  const std::string RegoCompileError = "rego_compile_error";
  const std::string EvalConflictError = "eval_conflict_error";
  const std::string WellFormedError = "wellformed_error";
  const std::string RuntimeError = "runtime_error";
  const std::string RecursionError = "rego_recursion_error";
  const std::string DefaultVersion = "v0";
 
  Node err(
    NodeRange& r,
    const std::string& msg,
    const std::string& code = UnknownError);
 
  Node err(
    Node node, const std::string& msg, const std::string& code = UnknownError);
 
  Node version();
 
  std::string to_key(
    const trieste::Node& node,
    bool set_as_array = false,
    bool sort_arrays = false);
 
  enum class LogLevel : char
  {
    None = REGO_LOG_LEVEL_NONE,
    Error = REGO_LOG_LEVEL_ERROR,
    Output = REGO_LOG_LEVEL_OUTPUT,
    Warn = REGO_LOG_LEVEL_WARN,
    Info = REGO_LOG_LEVEL_INFO,
    Debug = REGO_LOG_LEVEL_DEBUG,
    Trace = REGO_LOG_LEVEL_TRACE,
  };
 
  void set_log_level(LogLevel level);
 
  std::string set_log_level_from_string(const std::string& level);
 
  class Interpreter
  {
  public:
    Interpreter(bool v1_compatible = false);
 
    Node add_module_file(const std::filesystem::path& path);
 
    Node add_module(const std::string& name, const std::string& contents);
 
    Node add_data_json_file(const std::filesystem::path& path);
 
    Node add_data_json(const std::string& json);
 
    Node add_data(const Node& node);
 
    Node set_input_json_file(const std::filesystem::path& path);
 
    Node set_input_term(const std::string& term);
 
    Node set_input(const Node& node);
 
    std::string query(const std::string& query_expr);
 
    Node raw_query(const std::string& query_expr);
 
    Interpreter& debug_path(const std::filesystem::path& prefix);
    const std::filesystem::path& debug_path() const;
 
    Interpreter& debug_enabled(bool enabled);
    bool debug_enabled() const;
 
    Interpreter& wf_check_enabled(bool enabled);
    bool wf_check_enabled() const;
 
    BuiltInsDef& builtins() const;
 
  private:
    friend const char* ::regoGetError(regoInterpreter* rego);
    friend void setError(regoInterpreter* rego, const std::string& error);
    friend regoOutput* ::regoQuery(
      regoInterpreter* rego, const char* query_expr);
 
    void merge(const Node& ast);
    std::string output_to_string(const Node& output) const;
    Reader m_reader;
    Node m_ast;
    std::filesystem::path m_debug_path;
    BuiltIns m_builtins;
    Rewriter m_unify;
    Reader m_json;
    Rewriter m_from_json;
    Rewriter m_to_input;
    std::size_t m_data_count;
 
    std::string m_c_error;
  };
 
  Reader reader(bool v1_compatible = false);
 
  Rewriter to_input();
 
  Rewriter unify(BuiltIns builtins = BuiltInsDef::create());
 
  Rewriter from_json(bool as_term = false);
 
  Rewriter to_json();
 
  Rewriter to_yaml();
}