Method PostVisitExpr

eval/compiler/flat_expr_builder.cc:630–677

  }

  void PostVisitExpr(const cel::Expr& expr) override {
    if (!progress_status_.ok()) {
      return;
    }
    if (&expr == resume_from_suppressed_branch_) {
      resume_from_suppressed_branch_ = nullptr;
    }

    for (const std::unique_ptr<ProgramOptimizer>& optimizer :
         program_optimizers_) {
      absl::Status status = optimizer->OnPostVisit(extension_context_, expr);
      if (!status.ok()) {
        SetProgressStatusError(status);
        return;
      }
    }

    auto* subexpression = program_builder_.current();
    if (subexpression != nullptr && options_.enable_recursive_tracing &&
        subexpression->IsRecursive()) {
      auto program = subexpression->ExtractRecursiveProgram();
      subexpression->set_recursive_program(
          std::make_unique<TraceStep>(std::move(program.step)), program.depth);
    }

    program_builder_.ExitSubexpression(&expr);

    if (!comprehension_stack_.empty() &&
        comprehension_stack_.back().is_optimizable_bind &&
        (&comprehension_stack_.back().comprehension->accu_init() == &expr)) {
      SetProgressStatusError(
          MaybeExtractSubexpression(&expr, comprehension_stack_.back()));
    }

    if (block_.has_value()) {
      BlockInfo& block = *block_;
      if (block.current_binding == &expr) {
        int index = program_builder_.ExtractSubexpression(&expr);
        if (index == -1) {
          SetProgressStatusError(
              absl::InvalidArgumentError("failed to extract subexpression"));
          return;
        }
        block.subexpressions[block.current_index++] = index;
        block.current_binding = nullptr;
      }
    }
  }

  void PostVisitConst(const cel::Expr& expr,
                      const cel::Constant& const_expr) override {