Method Copy

parser/macro_expr_factory.cc:28–107

namespace cel {

Expr MacroExprFactory::Copy(const Expr& expr) {
  // Copying logic is recursive at the moment, we alter it to be iterative in
  // the future.
  return absl::visit(
      absl::Overload(
          [this, &expr](const UnspecifiedExpr&) -> Expr {
            return NewUnspecified(CopyId(expr));
          },
          [this, &expr](const Constant& const_expr) -> Expr {
            return NewConst(CopyId(expr), const_expr);
          },
          [this, &expr](const IdentExpr& ident_expr) -> Expr {
            return NewIdent(CopyId(expr), ident_expr.name());
          },
          [this, &expr](const SelectExpr& select_expr) -> Expr {
            const auto id = CopyId(expr);
            return select_expr.test_only()
                       ? NewPresenceTest(id, Copy(select_expr.operand()),
                                         select_expr.field())
                       : NewSelect(id, Copy(select_expr.operand()),
                                   select_expr.field());
          },
          [this, &expr](const CallExpr& call_expr) -> Expr {
            const auto id = CopyId(expr);
            absl::optional<Expr> target;
            if (call_expr.has_target()) {
              target = Copy(call_expr.target());
            }
            std::vector<Expr> args;
            args.reserve(call_expr.args().size());
            for (const auto& arg : call_expr.args()) {
              args.push_back(Copy(arg));
            }
            return target.has_value()
                       ? NewMemberCall(id, call_expr.function(),
                                       std::move(*target), std::move(args))
                       : NewCall(id, call_expr.function(), std::move(args));
          },
          [this, &expr](const ListExpr& list_expr) -> Expr {
            const auto id = CopyId(expr);
            std::vector<ListExprElement> elements;
            elements.reserve(list_expr.elements().size());
            for (const auto& element : list_expr.elements()) {
              elements.push_back(Copy(element));
            }
            return NewList(id, std::move(elements));
          },
          [this, &expr](const StructExpr& struct_expr) -> Expr {
            const auto id = CopyId(expr);
            std::vector<StructExprField> fields;
            fields.reserve(struct_expr.fields().size());
            for (const auto& field : struct_expr.fields()) {
              fields.push_back(Copy(field));
            }
            return NewStruct(id, struct_expr.name(), std::move(fields));
          },
          [this, &expr](const MapExpr& map_expr) -> Expr {
            const auto id = CopyId(expr);