std::string bytes;

bool operator==(const Bytes& other) const { return bytes == other.bytes; }

public:

constexpr Constant() = default;

explicit Constant(ConstantKind constant_kind)

: constant_kind_(std::move(constant_kind)) {}

void set_constant_kind(ConstantKind constant_kind) {

constant_kind_ = std::move(constant_kind);

}

const ConstantKind& constant_kind() const { return constant_kind_; }

ConstantKind& mutable_constant_kind() { return constant_kind_; }

bool has_null_value() const {

return absl::holds_alternative<NullValue>(constant_kind_);

}

NullValue null_value() const {

auto* value = absl::get_if<NullValue>(&constant_kind_);

if (value != nullptr) {

return *value;

}

return NullValue::kNullValue;

}

void set_null_value(NullValue null_value) { constant_kind_ = null_value; }

bool has_bool_value() const {

return absl::holds_alternative<bool>(constant_kind_);

}

bool bool_value() const {

auto* value = absl::get_if<bool>(&constant_kind_);

if (value != nullptr) {

return *value;

}

return false;

}

void set_bool_value(bool bool_value) { constant_kind_ = bool_value; }

bool has_int64_value() const {

return absl::holds_alternative<int64_t>(constant_kind_);

}

int64_t int64_value() const {

auto* value = absl::get_if<int64_t>(&constant_kind_);

if (value != nullptr) {

return *value;

}

return 0;

}

void set_int64_value(int64_t int64_value) { constant_kind_ = int64_value; }

bool has_uint64_value() const {

return absl::holds_alternative<uint64_t>(constant_kind_);

}

uint64_t uint64_value() const {

auto* value = absl::get_if<uint64_t>(&constant_kind_);

if (value != nullptr) {

return *value;

}

return 0;

}

void set_uint64_value(uint64_t uint64_value) {

constant_kind_ = uint64_value;

}

bool has_double_value() const {

return absl::holds_alternative<double>(constant_kind_);

}

double double_value() const {

auto* value = absl::get_if<double>(&constant_kind_);

if (value != nullptr) {

return *value;

}

return 0;

}

void set_double_value(double double_value) { constant_kind_ = double_value; }

bool has_string_value() const {

return absl::holds_alternative<std::string>(constant_kind_);

}

const std::string& string_value() const {

auto* value = absl::get_if<std::string>(&constant_kind_);

if (value != nullptr) {

return *value;

}

static std::string* default_string_value_ = new std::string("");

return *default_string_value_;

}

void set_string_value(std::string string_value) {

constant_kind_ = string_value;

}

bool has_bytes_value() const {

return absl::holds_alternative<Bytes>(constant_kind_);

}

const std::string& bytes_value() const {

auto* value = absl::get_if<Bytes>(&constant_kind_);

if (value != nullptr) {

return value->bytes;

}

static std::string* default_string_value_ = new std::string("");

return *default_string_value_;

}

void set_bytes_value(std::string bytes_value) {

constant_kind_ = Bytes{std::move(bytes_value)};

}

bool has_duration_value() const {

return absl::holds_alternative<absl::Duration>(constant_kind_);

}

void set_duration_value(absl::Duration duration_value) {

constant_kind_ = std::move(duration_value);

}

const absl::Duration& duration_value() const {

auto* value = absl::get_if<absl::Duration>(&constant_kind_);

if (value != nullptr) {

return *value;

}

static absl::Duration default_duration_;

return default_duration_;

}

bool has_time_value() const {

return absl::holds_alternative<absl::Time>(constant_kind_);

}

const absl::Time& time_value() const {

auto* value = absl::get_if<absl::Time>(&constant_kind_);

if (value != nullptr) {

return *value;

}

static absl::Time default_time_;

return default_time_;

}

void set_time_value(absl::Time time_value) {

constant_kind_ = std::move(time_value);

}

bool operator==(const Constant& other) const {

return constant_kind_ == other.constant_kind_;

}

private:

ConstantKind constant_kind_;

public:

Ident() = default;

explicit Ident(std::string name) : name_(std::move(name)) {}

void set_name(std::string name) { name_ = std::move(name); }

const std::string& name() const { return name_; }

bool operator==(const Ident& other) const { return name_ == other.name_; }

private:

// Required. Holds a single, unqualified identifier, possibly preceded by a

// '.'.

//

// Qualified names are represented by the [Expr.Select][] expression.

std::string name_;

public:

Select() = default;

Select(std::unique_ptr<Expr> operand, std::string field,

bool test_only = false)

: operand_(std::move(operand)),

field_(std::move(field)),

test_only_(test_only) {}

void set_operand(std::unique_ptr<Expr> operand) {

operand_ = std::move(operand);

}

void set_field(std::string field) { field_ = std::move(field); }

void set_test_only(bool test_only) { test_only_ = test_only; }

bool has_operand() const { return operand_ != nullptr; }

const Expr& operand() const;

Expr& mutable_operand() {

if (operand_ == nullptr) {

operand_ = std::make_unique<Expr>();

}

return *operand_;

}

const std::string& field() const { return field_; }

bool test_only() const { return test_only_; }

bool operator==(const Select& other) const;

private:

// Required. The target of the selection expression.

//

// For example, in the select expression `request.auth`, the `request`

// portion of the expression is the `operand`.

std::unique_ptr<Expr> operand_;

// Required. The name of the field to select.

//

// For example, in the select expression `request.auth`, the `auth` portion

// of the expression would be the `field`.

std::string field_;

// Whether the select is to be interpreted as a field presence test.

//

// This results from the macro `has(request.auth)`.

bool test_only_ = false;

public:

Call() = default;

Call(std::unique_ptr<Expr> target, std::string function,

std::vector<Expr> args);

void set_target(std::unique_ptr<Expr> target) { target_ = std::move(target); }

void set_function(std::string function) { function_ = std::move(function); }

void set_args(std::vector<Expr> args);

bool has_target() const { return target_ != nullptr; }

const Expr& target() const;

Expr& mutable_target() {

if (target_ == nullptr) {

target_ = std::make_unique<Expr>();

}

return *target_;

}

const std::string& function() const { return function_; }

const std::vector<Expr>& args() const { return args_; }

std::vector<Expr>& mutable_args() { return args_; }

bool operator==(const Call& other) const;

private:

// The target of an method call-style expression. For example, `x` in

// `x.f()`.

std::unique_ptr<Expr> target_;

// Required. The name of the function or method being called.

std::string function_;

// The arguments.

std::vector<Expr> args_;

public:

CreateList() = default;

explicit CreateList(std::vector<Expr> elements);

void set_elements(std::vector<Expr> elements);

const std::vector<Expr>& elements() const { return elements_; }

std::vector<Expr>& mutable_elements() { return elements_; }

bool operator==(const CreateList& other) const;

private:

// The elements part of the list.

std::vector<Expr> elements_;

public:

// Represents an entry.

class Entry {

public:

using KeyKind = absl::variant<std::string, std::unique_ptr<Expr>>;

Entry() = default;

Entry(int64_t id, KeyKind key_kind, std::unique_ptr<Expr> value)

: id_(id), key_kind_(std::move(key_kind)), value_(std::move(value)) {}

void set_id(int64_t id) { id_ = id; }

void set_key_kind(KeyKind key_kind) { key_kind_ = std::move(key_kind); }

void set_value(std::unique_ptr<Expr> value) { value_ = std::move(value); }

int64_t id() const { return id_; }

const KeyKind& key_kind() const { return key_kind_; }

KeyKind& mutable_key_kind() { return key_kind_; }

bool has_field_key() const {

return absl::holds_alternative<std::string>(key_kind_);

}

bool has_map_key() const {

return absl::holds_alternative<std::unique_ptr<Expr>>(key_kind_);

}

const std::string& field_key() const {

auto* value = absl::get_if<std::string>(&key_kind_);

if (value != nullptr) {

return *value;

}

static const std::string* default_field_key = new std::string;

return *default_field_key;

}

void set_field_key(std::string field_key) {

key_kind_ = std::move(field_key);

}

const Expr& map_key() const;

Expr& mutable_map_key() {

auto* value = absl::get_if<std::unique_ptr<Expr>>(&key_kind_);

if (value != nullptr) {

if (*value != nullptr) return **value;

}

key_kind_.emplace<std::unique_ptr<Expr>>(std::make_unique<Expr>());

return *absl::get<std::unique_ptr<Expr>>(key_kind_);

}

bool has_value() const { return value_ != nullptr; }

const Expr& value() const;

Expr& mutable_value() {

if (value_ == nullptr) {

value_ = std::make_unique<Expr>();

}

return *value_;

}

bool operator==(const Entry& other) const;

bool operator!=(const Entry& other) const { return !operator==(other); }

private:

// Required. An id assigned to this node by the parser which is unique

// in a given expression tree. This is used to associate type

// information and other attributes to the node.

int64_t id_ = 0;

// The `Entry` key kinds.

KeyKind key_kind_;

// Required. The value assigned to the key.

std::unique_ptr<Expr> value_;

};

CreateStruct() = default;

CreateStruct(std::string message_name, std::vector<Entry> entries)

: message_name_(std::move(message_name)), entries_(std::move(entries)) {}

void set_message_name(std::string message_name) {

message_name_ = std::move(message_name);

}

void set_entries(std::vector<Entry> entries) {

entries_ = std::move(entries);

}

const std::vector<Entry>& entries() const { return entries_; }

std::vector<Entry>& mutable_entries() { return entries_; }

const std::string& message_name() const { return message_name_; }

bool operator==(const CreateStruct& other) const {

return message_name_ == other.message_name_ && entries_ == other.entries_;

}

private:

// The type name of the message to be created, empty when creating map

// literals.

std::string message_name_;

// The entries in the creation expression.

std::vector<Entry> entries_;

public:

Comprehension() = default;

Comprehension(std::string iter_var, std::unique_ptr<Expr> iter_range,

std::string accu_var, std::unique_ptr<Expr> accu_init,

std::unique_ptr<Expr> loop_condition,

std::unique_ptr<Expr> loop_step, std::unique_ptr<Expr> result)

: iter_var_(std::move(iter_var)),

iter_range_(std::move(iter_range)),

accu_var_(std::move(accu_var)),

accu_init_(std::move(accu_init)),

loop_condition_(std::move(loop_condition)),

loop_step_(std::move(loop_step)),

result_(std::move(result)) {}

bool has_iter_range() const { return iter_range_ != nullptr; }

bool has_accu_init() const { return accu_init_ != nullptr; }

bool has_loop_condition() const { return loop_condition_ != nullptr; }

bool has_loop_step() const { return loop_step_ != nullptr; }

bool has_result() const { return result_ != nullptr; }

void set_iter_var(std::string iter_var) { iter_var_ = std::move(iter_var); }

void set_iter_range(std::unique_ptr<Expr> iter_range) {

iter_range_ = std::move(iter_range);

}

void set_accu_var(std::string accu_var) { accu_var_ = std::move(accu_var); }

void set_accu_init(std::unique_ptr<Expr> accu_init) {

accu_init_ = std::move(accu_init);

}

void set_loop_condition(std::unique_ptr<Expr> loop_condition) {

loop_condition_ = std::move(loop_condition);

}

void set_loop_step(std::unique_ptr<Expr> loop_step) {

loop_step_ = std::move(loop_step);

}

void set_result(std::unique_ptr<Expr> result) { result_ = std::move(result); }

const std::string& iter_var() const { return iter_var_; }

const Expr& iter_range() const;

Expr& mutable_iter_range() {

if (iter_range_ == nullptr) {

iter_range_ = std::make_unique<Expr>();

}

return *iter_range_;

}

const std::string& accu_var() const { return accu_var_; }

const Expr& accu_init() const;

Expr& mutable_accu_init() {

if (accu_init_ == nullptr) {

accu_init_ = std::make_unique<Expr>();

}

return *accu_init_;

}

const Expr& loop_condition() const;

Expr& mutable_loop_condition() {

if (loop_condition_ == nullptr) {

loop_condition_ = std::make_unique<Expr>();

}

return *loop_condition_;

}

const Expr& loop_step() const;

Expr& mutable_loop_step() {

if (loop_step_ == nullptr) {

loop_step_ = std::make_unique<Expr>();

}

return *loop_step_;

}

const Expr& result() const;

Expr& mutable_result() {

if (result_ == nullptr) {

result_ = std::make_unique<Expr>();

}

return *result_;

}

bool operator==(const Comprehension& other) const;

private:

// The name of the iteration variable.

std::string iter_var_;

// The range over which var iterates.

std::unique_ptr<Expr> iter_range_;

// The name of the variable used for accumulation of the result.

std::string accu_var_;

// The initial value of the accumulator.

std::unique_ptr<Expr> accu_init_;

// An expression which can contain iter_var and accu_var.

//

// Returns false when the result has been computed and may be used as

// a hint to short-circuit the remainder of the comprehension.

std::unique_ptr<Expr> loop_condition_;

// An expression which can contain iter_var and accu_var.

//

// Computes the next value of accu_var.

std::unique_ptr<Expr> loop_step_;

// An expression which can contain accu_var.

//

// Computes the result.

std::unique_ptr<Expr> result_;

public:

Expr() = default;

Expr(int64_t id, ExprKind expr_kind)

: id_(id), expr_kind_(std::move(expr_kind)) {}

Expr(Expr&& rhs) = default;

Expr& operator=(Expr&& rhs) = default;

void set_id(int64_t id) { id_ = id; }

void set_expr_kind(ExprKind expr_kind) { expr_kind_ = std::move(expr_kind); }

int64_t id() const { return id_; }

const ExprKind& expr_kind() const { return expr_kind_; }

ExprKind& mutable_expr_kind() { return expr_kind_; }

bool has_const_expr() const {

return absl::holds_alternative<Constant>(expr_kind_);

}

bool has_ident_expr() const {

return absl::holds_alternative<Ident>(expr_kind_);

}

bool has_select_expr() const {

return absl::holds_alternative<Select>(expr_kind_);

}

bool has_call_expr() const {

return absl::holds_alternative<Call>(expr_kind_);

}

bool has_list_expr() const {

return absl::holds_alternative<CreateList>(expr_kind_);

}

bool has_struct_expr() const {

return absl::holds_alternative<CreateStruct>(expr_kind_);

}

bool has_comprehension_expr() const {

return absl::holds_alternative<Comprehension>(expr_kind_);

}

const Constant& const_expr() const {

auto* value = absl::get_if<Constant>(&expr_kind_);

if (value != nullptr) {

return *value;

}

static const Constant* default_constant = new Constant;

return *default_constant;

}

Constant& mutable_const_expr() {

auto* value = absl::get_if<Constant>(&expr_kind_);

if (value != nullptr) {

return *value;

}

expr_kind_.emplace<Constant>();

return absl::get<Constant>(expr_kind_);

}

const Ident& ident_expr() const {

auto* value = absl::get_if<Ident>(&expr_kind_);

if (value != nullptr) {

return *value;

}

static const Ident* default_ident = new Ident;

return *default_ident;

}

Ident& mutable_ident_expr() {

auto* value = absl::get_if<Ident>(&expr_kind_);

if (value != nullptr) {

return *value;

}

expr_kind_.emplace<Ident>();

return absl::get<Ident>(expr_kind_);

}

const Select& select_expr() const {

auto* value = absl::get_if<Select>(&expr_kind_);

if (value != nullptr) {

return *value;

}

static const Select* default_select = new Select;

return *default_select;

}

Select& mutable_select_expr() {

auto* value = absl::get_if<Select>(&expr_kind_);

if (value != nullptr) {

return *value;

}

expr_kind_.emplace<Select>();

return absl::get<Select>(expr_kind_);

}

const Call& call_expr() const {

auto* value = absl::get_if<Call>(&expr_kind_);

if (value != nullptr) {

return *value;

}

static const Call* default_call = new Call;

return *default_call;

}

Call& mutable_call_expr() {

auto* value = absl::get_if<Call>(&expr_kind_);

if (value != nullptr) {

return *value;

}

expr_kind_.emplace<Call>();

return absl::get<Call>(expr_kind_);

}

const CreateList& list_expr() const {

auto* value = absl::get_if<CreateList>(&expr_kind_);

if (value != nullptr) {

return *value;

}

static const CreateList* default_create_list = new CreateList;

return *default_create_list;

}

CreateList& mutable_list_expr() {

auto* value = absl::get_if<CreateList>(&expr_kind_);

if (value != nullptr) {

return *value;

}

expr_kind_.emplace<CreateList>();

return absl::get<CreateList>(expr_kind_);

}

const CreateStruct& struct_expr() const {

auto* value = absl::get_if<CreateStruct>(&expr_kind_);

if (value != nullptr) {

return *value;

}

static const CreateStruct* default_create_struct = new CreateStruct;

return *default_create_struct;

}

CreateStruct& mutable_struct_expr() {

auto* value = absl::get_if<CreateStruct>(&expr_kind_);

if (value != nullptr) {

return *value;

}

expr_kind_.emplace<CreateStruct>();

return absl::get<CreateStruct>(expr_kind_);

}

const Comprehension& comprehension_expr() const {

auto* value = absl::get_if<Comprehension>(&expr_kind_);

if (value != nullptr) {

return *value;

}

static const Comprehension* default_comprehension = new Comprehension;

return *default_comprehension;

}

Comprehension& mutable_comprehension_expr() {

auto* value = absl::get_if<Comprehension>(&expr_kind_);

if (value != nullptr) {

return *value;

}

expr_kind_.emplace<Comprehension>();

return absl::get<Comprehension>(expr_kind_);

}

bool operator==(const Expr& other) const {

return id_ == other.id_ && expr_kind_ == other.expr_kind_;

}

private:

// Required. An id assigned to this node by the parser which is unique in a

// given expression tree. This is used to associate type information and other

// attributes to a node in the parse tree.

int64_t id_ = 0;

// Required. Variants of expressions.

ExprKind expr_kind_;

public:

SourceInfo() = default;

SourceInfo(std::string syntax_version, std::string location,

std::vector<int32_t> line_offsets,

absl::flat_hash_map<int64_t, int32_t> positions,

absl::flat_hash_map<int64_t, Expr> macro_calls)

: syntax_version_(std::move(syntax_version)),

location_(std::move(location)),

line_offsets_(std::move(line_offsets)),

positions_(std::move(positions)),

macro_calls_(std::move(macro_calls)) {}

void set_syntax_version(std::string syntax_version) {

syntax_version_ = std::move(syntax_version);

}

void set_location(std::string location) { location_ = std::move(location); }

void set_line_offsets(std::vector<int32_t> line_offsets) {

line_offsets_ = std::move(line_offsets);

}

void set_positions(absl::flat_hash_map<int64_t, int32_t> positions) {

positions_ = std::move(positions);

}

void set_macro_calls(absl::flat_hash_map<int64_t, Expr> macro_calls) {

macro_calls_ = std::move(macro_calls);

}

const std::string& syntax_version() const { return syntax_version_; }

const std::string& location() const { return location_; }

const std::vector<int32_t>& line_offsets() const { return line_offsets_; }

std::vector<int32_t>& mutable_line_offsets() { return line_offsets_; }

const absl::flat_hash_map<int64_t, int32_t>& positions() const {

return positions_;

}

absl::flat_hash_map<int64_t, int32_t>& mutable_positions() {

return positions_;

}

const absl::flat_hash_map<int64_t, Expr>& macro_calls() const {

return macro_calls_;

}

absl::flat_hash_map<int64_t, Expr>& mutable_macro_calls() {

return macro_calls_;

}

private:

// The syntax version of the source, e.g. `cel1`.

std::string syntax_version_;

// The location name. All position information attached to an expression is

// relative to this location.

//

// The location could be a file, UI element, or similar. For example,

// `acme/app/AnvilPolicy.cel`.

std::string location_;

// Monotonically increasing list of code point offsets where newlines

// `\n` appear.

//

// The line number of a given position is the index `i` where for a given

// `id` the `line_offsets[i] < id_positions[id] < line_offsets[i+1]`. The

// column may be derivd from `id_positions[id] - line_offsets[i]`.

//

// TODO(issues/5): clarify this documentation

std::vector<int32_t> line_offsets_;

// A map from the parse node id (e.g. `Expr.id`) to the code point offset

// within source.

absl::flat_hash_map<int64_t, int32_t> positions_;

// A map from the parse node id where a macro replacement was made to the

// call `Expr` that resulted in a macro expansion.

//

// For example, `has(value.field)` is a function call that is replaced by a

// `test_only` field selection in the AST. Likewise, the call

// `list.exists(e, e > 10)` translates to a comprehension expression. The key

// in the map corresponds to the expression id of the expanded macro, and the

// value is the call `Expr` that was replaced.

absl::flat_hash_map<int64_t, Expr> macro_calls_;

public:

ParsedExpr() = default;

ParsedExpr(Expr expr, SourceInfo source_info)

: expr_(std::move(expr)), source_info_(std::move(source_info)) {}

ParsedExpr(ParsedExpr&& rhs) = default;

ParsedExpr& operator=(ParsedExpr&& rhs) = default;

void set_expr(Expr expr) { expr_ = std::move(expr); }

void set_source_info(SourceInfo source_info) {

source_info_ = std::move(source_info);

}

const Expr& expr() const { return expr_; }

Expr& mutable_expr() { return expr_; }

const SourceInfo& source_info() const { return source_info_; }

SourceInfo& mutable_source_info() { return source_info_; }

private:

// The parsed expression.

Expr expr_;

// The source info derived from input that generated the parsed `expr`.

SourceInfo source_info_;

// Unspecified type.

kPrimitiveTypeUnspecified = 0,

// Boolean type.