const ParserError& error) {

auto location =

source.GetLocation(error.range.begin).value_or(SourceLocation{});

return absl::StrCat(absl::StrFormat("ERROR: %s:%zu:%zu: %s",

source.description(), location.line,

// add one to the 0-based column

location.column + 1, error.message),

source.DisplayErrorLocation(location));

SourceRange range;

if (token != nullptr) {

if (auto start = token->getStartIndex(); start != INVALID_INDEX) {

range.begin = static_cast<int32_t>(start);

}

if (auto end = token->getStopIndex(); end != INVALID_INDEX) {

range.end = static_cast<int32_t>(end + 1);

}

}

return range;

const antlr4::ParserRuleContext* context) {

SourceRange range;

if (context != nullptr) {

if (auto start = context->getStart() != nullptr

? context->getStart()->getStartIndex()

: INVALID_INDEX;

start != INVALID_INDEX) {

range.begin = static_cast<int32_t>(start);

}

if (auto end = context->getStop() != nullptr

? context->getStop()->getStopIndex()

: INVALID_INDEX;

end != INVALID_INDEX) {

range.end = static_cast<int32_t>(end + 1);

}

}

return range;

public:

explicit ParserMacroExprFactory(const cel::Source& source,

absl::string_view accu_var)

: MacroExprFactory(accu_var), source_(source) {}

void BeginMacro(SourceRange macro_position) {

macro_position_ = macro_position;

}

void EndMacro() { macro_position_ = SourceRange{}; }

Expr ReportError(absl::string_view message) override {

return ReportError(macro_position_, message);

}

Expr ReportError(int64_t expr_id, absl::string_view message) {

return ReportError(GetSourceRange(expr_id), message);

}

Expr ReportError(SourceRange range, absl::string_view message) {

++error_count_;

if (errors_.size() <= 100) {

errors_.push_back(ParserError{std::string(message), range});

}

return NewUnspecified(NextId(range));

}

Expr ReportErrorAt(const Expr& expr, absl::string_view message) override {

return ReportError(GetSourceRange(expr.id()), message);

}

SourceRange GetSourceRange(int64_t id) const {

if (auto it = positions_.find(id); it != positions_.end()) {

return it->second;

}

return SourceRange{};

}

int64_t NextId(const SourceRange& range) {

auto id = expr_id_++;

if (range.begin != -1 || range.end != -1) {

positions_.insert(std::pair{id, range});

}

return id;

}

bool HasErrors() const { return error_count_ != 0; }

std::string ErrorMessage() {

// Errors are collected as they are encountered, not by their location

// within the source. To have a more stable error message as implementation

// details change, we sort the collected errors by their source location

// first.

std::stable_sort(

errors_.begin(), errors_.end(),

[](const ParserError& lhs, const ParserError& rhs) -> bool {

auto lhs_begin = PositiveOrMax(lhs.range.begin);

auto lhs_end = PositiveOrMax(lhs.range.end);

auto rhs_begin = PositiveOrMax(rhs.range.begin);

auto rhs_end = PositiveOrMax(rhs.range.end);

return lhs_begin < rhs_begin ||

(lhs_begin == rhs_begin && lhs_end < rhs_end);

});

// Build the summary error message using the sorted errors.

bool errors_truncated = error_count_ > 100;

std::vector<std::string> messages;

messages.reserve(

errors_.size() +

errors_truncated); // Reserve space for the transform and an

// additional element when truncation occurs.

std::transform(errors_.begin(), errors_.end(), std::back_inserter(messages),

[this](const ParserError& error) {

return cel::DisplayParserError(source_, error);

});

if (errors_truncated) {

messages.emplace_back(

absl::StrCat(error_count_ - 100, " more errors were truncated."));

}

return absl::StrJoin(messages, "\n");

}

void AddMacroCall(int64_t macro_id, absl::string_view function,

absl::optional<Expr> target, std::vector<Expr> arguments) {

macro_calls_.insert(

{macro_id, target.has_value()

? NewMemberCall(0, function, std::move(*target),

std::move(arguments))

: NewCall(0, function, std::move(arguments))});

}

Expr BuildMacroCallArg(const Expr& expr) {

if (auto it = macro_calls_.find(expr.id()); it != macro_calls_.end()) {

return NewUnspecified(expr.id());

}

return absl::visit(

absl::Overload(

[this, &expr](const UnspecifiedExpr&) -> Expr {

return NewUnspecified(expr.id());

},

[this, &expr](const Constant& const_expr) -> Expr {

return NewConst(expr.id(), const_expr);

},

[this, &expr](const IdentExpr& ident_expr) -> Expr {

return NewIdent(expr.id(), ident_expr.name());

},

[this, &expr](const SelectExpr& select_expr) -> Expr {

return select_expr.test_only()

? NewPresenceTest(

expr.id(),

BuildMacroCallArg(select_expr.operand()),

select_expr.field())

: NewSelect(expr.id(),

BuildMacroCallArg(select_expr.operand()),

select_expr.field());

},

[this, &expr](const CallExpr& call_expr) -> Expr {

std::vector<Expr> macro_arguments;

macro_arguments.reserve(call_expr.args().size());

for (const auto& argument : call_expr.args()) {

macro_arguments.push_back(BuildMacroCallArg(argument));

}

absl::optional<Expr> macro_target;

if (call_expr.has_target()) {

macro_target = BuildMacroCallArg(call_expr.target());

}

return macro_target.has_value()

? NewMemberCall(expr.id(), call_expr.function(),

std::move(*macro_target),

std::move(macro_arguments))

: NewCall(expr.id(), call_expr.function(),

std::move(macro_arguments));

},

[this, &expr](const ListExpr& list_expr) -> Expr {

std::vector<ListExprElement> macro_elements;

macro_elements.reserve(list_expr.elements().size());

for (const auto& element : list_expr.elements()) {

auto& cloned_element = macro_elements.emplace_back();

if (element.has_expr()) {

cloned_element.set_expr(BuildMacroCallArg(element.expr()));

}

cloned_element.set_optional(element.optional());

}

return NewList(expr.id(), std::move(macro_elements));

},

[this, &expr](const StructExpr& struct_expr) -> Expr {

std::vector<StructExprField> macro_fields;

macro_fields.reserve(struct_expr.fields().size());

for (const auto& field : struct_expr.fields()) {

auto& macro_field = macro_fields.emplace_back();

macro_field.set_id(field.id());

macro_field.set_name(field.name());

macro_field.set_value(BuildMacroCallArg(field.value()));

macro_field.set_optional(field.optional());

}

return NewStruct(expr.id(), struct_expr.name(),

std::move(macro_fields));

},

[this, &expr](const MapExpr& map_expr) -> Expr {

std::vector<MapExprEntry> macro_entries;

macro_entries.reserve(map_expr.entries().size());

for (const auto& entry : map_expr.entries()) {

auto& macro_entry = macro_entries.emplace_back();

macro_entry.set_id(entry.id());

macro_entry.set_key(BuildMacroCallArg(entry.key()));

macro_entry.set_value(BuildMacroCallArg(entry.value()));

macro_entry.set_optional(entry.optional());

}

return NewMap(expr.id(), std::move(macro_entries));

},

[this, &expr](const ComprehensionExpr& comprehension_expr) -> Expr {

return NewComprehension(

expr.id(), comprehension_expr.iter_var(),

BuildMacroCallArg(comprehension_expr.iter_range()),

comprehension_expr.accu_var(),

BuildMacroCallArg(comprehension_expr.accu_init()),

BuildMacroCallArg(comprehension_expr.loop_condition()),

BuildMacroCallArg(comprehension_expr.loop_step()),

BuildMacroCallArg(comprehension_expr.result()));

}),

expr.kind());

}

using ExprFactory::NewBoolConst;

using ExprFactory::NewBytesConst;

using ExprFactory::NewCall;

using ExprFactory::NewComprehension;

using ExprFactory::NewConst;

using ExprFactory::NewDoubleConst;

using ExprFactory::NewIdent;

using ExprFactory::NewIntConst;

using ExprFactory::NewList;

using ExprFactory::NewListElement;

using ExprFactory::NewMap;

using ExprFactory::NewMapEntry;

using ExprFactory::NewMemberCall;

using ExprFactory::NewNullConst;

using ExprFactory::NewPresenceTest;

using ExprFactory::NewSelect;

using ExprFactory::NewStringConst;

using ExprFactory::NewStruct;

using ExprFactory::NewStructField;

using ExprFactory::NewUintConst;

using ExprFactory::NewUnspecified;

const absl::btree_map<int64_t, SourceRange>& positions() const {

return positions_;

}

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

return macro_calls_;

}

absl::flat_hash_map<int64_t, Expr> release_macro_calls() {

using std::swap;

absl::flat_hash_map<int64_t, Expr> result;

swap(result, macro_calls_);

return result;

}

void EraseId(ExprId id) {

positions_.erase(id);

if (expr_id_ == id + 1) {

--expr_id_;

}

}

protected:

int64_t NextId() override { return NextId(macro_position_); }

int64_t CopyId(int64_t id) override {

if (id == 0) {

return 0;

}

return NextId(GetSourceRange(id));

}

private:

int64_t expr_id_ = 1;

absl::btree_map<int64_t, SourceRange> positions_;

absl::flat_hash_map<int64_t, Expr> macro_calls_;

std::vector<ParserError> errors_;

size_t error_count_ = 0;

const Source& source_;

SourceRange macro_position_;

public:

CodePointStream(cel::SourceContentView buffer, absl::string_view source_name)

: buffer_(buffer),

source_name_(source_name),

size_(buffer_.size()),

index_(0) {}

void consume() override {

if (ABSL_PREDICT_FALSE(index_ >= size_)) {

ABSL_ASSERT(LA(1) == IntStream::EOF);

throw antlr4::IllegalStateException("cannot consume EOF");

}

index_++;

}

size_t LA(ptrdiff_t i) override {

if (ABSL_PREDICT_FALSE(i == 0)) {

return 0;

}

auto p = static_cast<ptrdiff_t>(index_);

if (i < 0) {

i++;

if (p + i - 1 < 0) {

return IntStream::EOF;

}

}

if (p + i - 1 >= static_cast<ptrdiff_t>(size_)) {

return IntStream::EOF;

}

return buffer_.at(static_cast<size_t>(p + i - 1));

}

ptrdiff_t mark() override { return -1; }

void release(ptrdiff_t marker) override {}

size_t index() override { return index_; }

void seek(size_t index) override { index_ = std::min(index, size_); }

size_t size() override { return size_; }

std::string getSourceName() const override {

return source_name_.empty() ? IntStream::UNKNOWN_SOURCE_NAME

: std::string(source_name_);

}

std::string getText(const antlr4::misc::Interval& interval) override {

if (ABSL_PREDICT_FALSE(interval.a < 0 || interval.b < 0)) {

return std::string();

}

size_t start = static_cast<size_t>(interval.a);

if (ABSL_PREDICT_FALSE(start >= size_)) {

return std::string();

}

size_t stop = static_cast<size_t>(interval.b);

if (ABSL_PREDICT_FALSE(stop >= size_)) {

stop = size_ - 1;

}

return buffer_.ToString(static_cast<cel::SourcePosition>(start),

static_cast<cel::SourcePosition>(stop) + 1);

}

std::string toString() const override { return buffer_.ToString(); }

private:

cel::SourceContentView const buffer_;

const absl::string_view source_name_;

const size_t size_;

size_t index_;

public:

explicit ScopedIncrement(int& recursion_depth)

: recursion_depth_(recursion_depth) {

++recursion_depth_;

}

~ScopedIncrement() { --recursion_depth_; }

private:

int& recursion_depth_;

public:

ExpressionBalancer(cel::ParserMacroExprFactory& factory, std::string function,

Expr expr);

// addTerm adds an operation identifier and term to the set of terms to be

// balanced.

void AddTerm(int64_t op, Expr term);

// balance creates a balanced tree from the sub-terms and returns the final

// Expr value.

Expr Balance();

private:

// balancedTree recursively balances the terms provided to a commutative

// operator.

Expr BalancedTree(int lo, int hi);

private:

cel::ParserMacroExprFactory& factory_;

std::string function_;

std::vector<Expr> terms_;

std::vector<int64_t> ops_;

std::string function, Expr expr)

: factory_(factory), function_(std::move(function)) {

terms_.push_back(std::move(expr));

if (terms_.size() == 1) {

return std::move(terms_[0]);

}

return BalancedTree(0, ops_.size() - 1);

int mid = (lo + hi + 1) / 2;

std::vector<Expr> arguments;

arguments.reserve(2);

if (mid == lo) {

arguments.push_back(std::move(terms_[mid]));

} else {

arguments.push_back(BalancedTree(lo, mid - 1));

}

if (mid == hi) {

arguments.push_back(std::move(terms_[mid + 1]));

} else {

arguments.push_back(BalancedTree(mid + 1, hi));

}

return factory_.NewCall(ops_[mid], function_, std::move(arguments));

public antlr4::BaseErrorListener {

public:

ParserVisitor(const cel::Source& source, int max_recursion_depth,

absl::string_view accu_var,

const cel::MacroRegistry& macro_registry,

bool add_macro_calls = false,

bool enable_optional_syntax = false,

bool enable_quoted_identifiers = false)

: source_(source),

factory_(source_, accu_var),

macro_registry_(macro_registry),

recursion_depth_(0),

max_recursion_depth_(max_recursion_depth),

add_macro_calls_(add_macro_calls),

enable_optional_syntax_(enable_optional_syntax),

enable_quoted_identifiers_(enable_quoted_identifiers) {}

~ParserVisitor() override = default;

std::any visit(antlr4::tree::ParseTree* tree) override;

std::any visitStart(CelParser::StartContext* ctx) override;

std::any visitExpr(CelParser::ExprContext* ctx) override;

std::any visitConditionalOr(CelParser::ConditionalOrContext* ctx) override;

std::any visitConditionalAnd(CelParser::ConditionalAndContext* ctx) override;

std::any visitRelation(CelParser::RelationContext* ctx) override;

std::any visitCalc(CelParser::CalcContext* ctx) override;

std::any visitUnary(CelParser::UnaryContext* ctx);

std::any visitLogicalNot(CelParser::LogicalNotContext* ctx) override;

std::any visitNegate(CelParser::NegateContext* ctx) override;

std::any visitSelect(CelParser::SelectContext* ctx) override;

std::any visitMemberCall(CelParser::MemberCallContext* ctx) override;

std::any visitIndex(CelParser::IndexContext* ctx) override;

std::any visitCreateMessage(CelParser::CreateMessageContext* ctx) override;

std::any visitFieldInitializerList(

CelParser::FieldInitializerListContext* ctx) override;

std::vector<StructExprField> visitFields(

CelParser::FieldInitializerListContext* ctx);

std::any visitGlobalCall(CelParser::GlobalCallContext* ctx) override;

std::any visitIdent(CelParser::IdentContext* ctx) override;

std::any visitNested(CelParser::NestedContext* ctx) override;

std::any visitCreateList(CelParser::CreateListContext* ctx) override;

std::vector<ListExprElement> visitList(CelParser::ListInitContext* ctx);

std::vector<Expr> visitList(CelParser::ExprListContext* ctx);

std::any visitCreateMap(CelParser::CreateMapContext* ctx) override;

std::any visitConstantLiteral(

CelParser::ConstantLiteralContext* ctx) override;

std::any visitPrimaryExpr(CelParser::PrimaryExprContext* ctx) override;

std::any visitMemberExpr(CelParser::MemberExprContext* ctx) override;

std::any visitMapInitializerList(

CelParser::MapInitializerListContext* ctx) override;

std::vector<MapExprEntry> visitEntries(

CelParser::MapInitializerListContext* ctx);

std::any visitInt(CelParser::IntContext* ctx) override;

std::any visitUint(CelParser::UintContext* ctx) override;

std::any visitDouble(CelParser::DoubleContext* ctx) override;

std::any visitString(CelParser::StringContext* ctx) override;

std::any visitBytes(CelParser::BytesContext* ctx) override;

std::any visitBoolTrue(CelParser::BoolTrueContext* ctx) override;

std::any visitBoolFalse(CelParser::BoolFalseContext* ctx) override;

std::any visitNull(CelParser::NullContext* ctx) override;

// Note: this is destructive and intended to be called after the parse is

// finished.

cel::SourceInfo GetSourceInfo();

EnrichedSourceInfo enriched_source_info() const;

void syntaxError(antlr4::Recognizer* recognizer,

antlr4::Token* offending_symbol, size_t line, size_t col,

const std::string& msg, std::exception_ptr e) override;

bool HasErrored() const;

std::string ErrorMessage();

private:

template <typename... Args>

Expr GlobalCallOrMacro(int64_t expr_id, absl::string_view function,

Args&&... args) {

std::vector<Expr> arguments;

arguments.reserve(sizeof...(Args));

(arguments.push_back(std::forward<Args>(args)), ...);

return GlobalCallOrMacroImpl(expr_id, function, std::move(arguments));

}

Expr GlobalCallOrMacroImpl(int64_t expr_id, absl::string_view function,

std::vector<Expr> args);

Expr ReceiverCallOrMacroImpl(int64_t expr_id, absl::string_view function,

Expr target, std::vector<Expr> args);

std::string ExtractQualifiedName(antlr4::ParserRuleContext* ctx,

const Expr& e);

std::string NormalizeIdentifier(CelParser::EscapeIdentContext* ctx);

// Attempt to unnest parse context.

//

// Walk the parse tree to the first complex term to reduce recursive depth in

// the visit* calls.

antlr4::tree::ParseTree* UnnestContext(antlr4::tree::ParseTree* tree);

private:

const cel::Source& source_;

cel::ParserMacroExprFactory factory_;

const cel::MacroRegistry& macro_registry_;

int recursion_depth_;

const int max_recursion_depth_;

const bool add_macro_calls_;

const bool enable_optional_syntax_;

const bool enable_quoted_identifiers_;

ScopedIncrement inc(recursion_depth_);

if (recursion_depth_ > max_recursion_depth_) {

return ExprToAny(factory_.ReportError(

absl::StrFormat("Exceeded max recursion depth of %d when parsing.",

max_recursion_depth_)));

}

tree = UnnestContext(tree);

if (auto* ctx = tree_as<CelParser::StartContext>(tree)) {

return visitStart(ctx);

} else if (auto* ctx = tree_as<CelParser::ExprContext>(tree)) {

return visitExpr(ctx);

} else if (auto* ctx = tree_as<CelParser::ConditionalAndContext>(tree)) {

return visitConditionalAnd(ctx);

} else if (auto* ctx = tree_as<CelParser::ConditionalOrContext>(tree)) {

return visitConditionalOr(ctx);

} else if (auto* ctx = tree_as<CelParser::RelationContext>(tree)) {

return visitRelation(ctx);

} else if (auto* ctx = tree_as<CelParser::CalcContext>(tree)) {

return visitCalc(ctx);

} else if (auto* ctx = tree_as<CelParser::LogicalNotContext>(tree)) {

return visitLogicalNot(ctx);

} else if (auto* ctx = tree_as<CelParser::PrimaryExprContext>(tree)) {

return visitPrimaryExpr(ctx);

} else if (auto* ctx = tree_as<CelParser::MemberExprContext>(tree)) {

return visitMemberExpr(ctx);

} else if (auto* ctx = tree_as<CelParser::SelectContext>(tree)) {

return visitSelect(ctx);

} else if (auto* ctx = tree_as<CelParser::MemberCallContext>(tree)) {

return visitMemberCall(ctx);

} else if (auto* ctx = tree_as<CelParser::MapInitializerListContext>(tree)) {

return visitMapInitializerList(ctx);

} else if (auto* ctx = tree_as<CelParser::NegateContext>(tree)) {

return visitNegate(ctx);

} else if (auto* ctx = tree_as<CelParser::IndexContext>(tree)) {

return visitIndex(ctx);

} else if (auto* ctx = tree_as<CelParser::UnaryContext>(tree)) {

return visitUnary(ctx);

} else if (auto* ctx = tree_as<CelParser::CreateListContext>(tree)) {

return visitCreateList(ctx);

} else if (auto* ctx = tree_as<CelParser::CreateMessageContext>(tree)) {

return visitCreateMessage(ctx);

} else if (auto* ctx = tree_as<CelParser::CreateMapContext>(tree)) {

return visitCreateMap(ctx);

}

if (tree) {

return ExprToAny(

factory_.ReportError(SourceRangeFromParserRuleContext(

tree_as<antlr4::ParserRuleContext>(tree)),

"unknown parsetree type"));

}

return ExprToAny(factory_.ReportError("<<nil>> parsetree"));

CelParser::PrimaryContext* primary = pctx->primary();

if (auto* ctx = tree_as<CelParser::NestedContext>(primary)) {

return visitNested(ctx);

} else if (auto* ctx = tree_as<CelParser::IdentContext>(primary)) {

return visitIdent(ctx);

} else if (auto* ctx = tree_as<CelParser::GlobalCallContext>(primary)) {

return visitGlobalCall(ctx);

} else if (auto* ctx = tree_as<CelParser::CreateListContext>(primary)) {

return visitCreateList(ctx);

} else if (auto* ctx = tree_as<CelParser::CreateMapContext>(primary)) {

return visitCreateMap(ctx);

} else if (auto* ctx = tree_as<CelParser::CreateMessageContext>(primary)) {

return visitCreateMessage(ctx);

} else if (auto* ctx = tree_as<CelParser::ConstantLiteralContext>(primary)) {

return visitConstantLiteral(ctx);

}

if (factory_.HasErrors()) {

// ANTLR creates PrimaryContext rather than a derived class during certain

// error conditions. This is odd, but we ignore it as we already have errors

// that occurred.

return ExprToAny(factory_.NewUnspecified(factory_.NextId({})));

}

return ExprToAny(factory_.ReportError(SourceRangeFromParserRuleContext(pctx),

"invalid primary expression"));

CelParser::MemberContext* member = mctx->member();

if (auto* ctx = tree_as<CelParser::PrimaryExprContext>(member)) {

return visitPrimaryExpr(ctx);

} else if (auto* ctx = tree_as<CelParser::SelectContext>(member)) {

return visitSelect(ctx);

} else if (auto* ctx = tree_as<CelParser::MemberCallContext>(member)) {

return visitMemberCall(ctx);

} else if (auto* ctx = tree_as<CelParser::IndexContext>(member)) {

return visitIndex(ctx);

}

return ExprToAny(factory_.ReportError(SourceRangeFromParserRuleContext(mctx),

"unsupported simple expression"));

auto result = ExprFromAny(visit(ctx->e));

if (!ctx->op) {

return ExprToAny(std::move(result));

}

std::vector<Expr> arguments;

arguments.reserve(3);

arguments.push_back(std::move(result));

int64_t op_id = factory_.NextId(SourceRangeFromToken(ctx->op));

arguments.push_back(ExprFromAny(visit(ctx->e1)));

arguments.push_back(ExprFromAny(visit(ctx->e2)));

return ExprToAny(

factory_.NewCall(op_id, CelOperator::CONDITIONAL, std::move(arguments)));

CelParser::ConditionalOrContext* ctx) {

auto result = ExprFromAny(visit(ctx->e));

if (ctx->ops.empty()) {

return ExprToAny(std::move(result));

}

ExpressionBalancer b(factory_, CelOperator::LOGICAL_OR, std::move(result));

for (size_t i = 0; i < ctx->ops.size(); ++i) {

auto op = ctx->ops[i];

if (i >= ctx->e1.size()) {

return ExprToAny(

factory_.ReportError(SourceRangeFromParserRuleContext(ctx),

"unexpected character, wanted '||'"));

}

auto next = ExprFromAny(visit(ctx->e1[i]));

int64_t op_id = factory_.NextId(SourceRangeFromToken(op));

b.AddTerm(op_id, std::move(next));

}

return ExprToAny(b.Balance());

CelParser::ConditionalAndContext* ctx) {

auto result = ExprFromAny(visit(ctx->e));

if (ctx->ops.empty()) {

return ExprToAny(std::move(result));

}

ExpressionBalancer b(factory_, CelOperator::LOGICAL_AND, std::move(result));

for (size_t i = 0; i < ctx->ops.size(); ++i) {

auto op = ctx->ops[i];

if (i >= ctx->e1.size()) {

return ExprToAny(

factory_.ReportError(SourceRangeFromParserRuleContext(ctx),

"unexpected character, wanted '&&'"));

}

auto next = ExprFromAny(visit(ctx->e1[i]));

int64_t op_id = factory_.NextId(SourceRangeFromToken(op));

b.AddTerm(op_id, std::move(next));

}

return ExprToAny(b.Balance());

if (ctx->calc()) {

return visit(ctx->calc());

}

std::string op_text;

if (ctx->op) {

op_text = ctx->op->getText();

}

auto op = ReverseLookupOperator(op_text);

if (op) {

auto lhs = ExprFromAny(visit(ctx->relation(0)));

int64_t op_id = factory_.NextId(SourceRangeFromToken(ctx->op));

auto rhs = ExprFromAny(visit(ctx->relation(1)));

return ExprToAny(

GlobalCallOrMacro(op_id, *op, std::move(lhs), std::move(rhs)));

}

return ExprToAny(factory_.ReportError(SourceRangeFromParserRuleContext(ctx),

"operator not found"));

if (ctx->unary()) {

return visit(ctx->unary());

}

std::string op_text;

if (ctx->op) {

op_text = ctx->op->getText();

}

auto op = ReverseLookupOperator(op_text);

if (op) {

auto lhs = ExprFromAny(visit(ctx->calc(0)));

int64_t op_id = factory_.NextId(SourceRangeFromToken(ctx->op));

auto rhs = ExprFromAny(visit(ctx->calc(1)));

return ExprToAny(

GlobalCallOrMacro(op_id, *op, std::move(lhs), std::move(rhs)));

}

return ExprToAny(factory_.ReportError(SourceRangeFromParserRuleContext(ctx),

"operator not found"));

if (ctx->ops.size() % 2 == 0) {

return visit(ctx->member());

}

int64_t op_id = factory_.NextId(SourceRangeFromToken(ctx->ops[0]));

auto target = ExprFromAny(visit(ctx->member()));

return ExprToAny(

GlobalCallOrMacro(op_id, CelOperator::LOGICAL_NOT, std::move(target)));

if (ctx->ops.size() % 2 == 0) {

return visit(ctx->member());

}

int64_t op_id = factory_.NextId(SourceRangeFromToken(ctx->ops[0]));