Method Flatten

eval/compiler/flat_expr_builder_extensions.cc:198–253

}

void Subexpression::Flatten() {
  struct Record {
    Subexpression* subexpr;
    size_t offset;
  };

  if (IsFlattened()) {
    return;
  }

  std::vector<std::unique_ptr<const ExpressionStep>> flat;

  std::vector<Record> flatten_stack;

  flatten_stack.push_back({this, 0});
  while (!flatten_stack.empty()) {
    Record top = flatten_stack.back();
    flatten_stack.pop_back();
    size_t offset = top.offset;
    auto* subexpr = top.subexpr;
    if (subexpr->IsFlattened()) {
      auto& elements = subexpr->flattened_elements();
      absl::c_move(elements, std::back_inserter(flat));
      elements.clear();
      continue;
    } else if (subexpr->IsRecursive()) {
      flat.push_back(std::make_unique<WrappedDirectStep>(
          std::move(subexpr->ExtractRecursiveProgram().step),
          subexpr->self_->id()));
      continue;
    }
    auto& elements = subexpr->elements();
    size_t size = elements.size();
    size_t i = offset;
    for (; i < size; ++i) {
      auto& element = elements[i];
      if (auto* child = absl::get_if<Subexpression*>(&element);
          child != nullptr) {
        // push resume then child so child elements are processed first.
        flatten_stack.push_back({subexpr, i + 1});
        flatten_stack.push_back({*child, 0});
        break;
      } else if (auto* step =
                     absl::get_if<std::unique_ptr<ExpressionStep>>(&element);
                 step != nullptr) {
        flat.push_back(std::move(*step));
      } else {
        ABSL_UNREACHABLE();
      }
    }
    if (i == size) {
      elements.clear();
    }
  }
  program_ = std::move(flat);
}

Subexpression::RecursiveProgram Subexpression::ExtractRecursiveProgram() {