Function compileInputs

bolt/expression/ExprCompiler.cpp:203–629

#ifdef ENABLE_BOLT_EXPR_JIT
std::vector<ExprPtr> compileInputs(
    const TypedExprPtr& expr,
    Scope* scope,
    const core::QueryConfig& config,
    memory::MemoryPool* pool,
    const std::unordered_set<std::string>& flatteningCandidates,
    bool enableConstantFolding,
    bool isRootExpr = false) {
#else
std::vector<ExprPtr> compileInputs(
    const TypedExprPtr& expr,
    Scope* scope,
    const core::QueryConfig& config,
    memory::MemoryPool* pool,
    const std::unordered_set<std::string>& flatteningCandidates,
    bool enableConstantFolding) {
#endif
  std::vector<ExprPtr> compiledInputs;
  auto flattenIf = shouldFlatten(expr, flatteningCandidates);
  for (auto& input : expr->inputs()) {
    if (dynamic_cast<const core::InputTypedExpr*>(input.get())) {
      BOLT_CHECK(
          dynamic_cast<const core::FieldAccessTypedExpr*>(expr.get()),
          "An InputReference can only occur under a FieldReference");
    } else {
      if (flattenIf.has_value()) {
        std::vector<TypedExprPtr> flat;
        flattenInput(input, flattenIf.value(), flat);
        for (auto& input_2 : flat) {
          compiledInputs.push_back(compileExpression(
              input_2,
              scope,
              config,
              pool,
              flatteningCandidates,
              enableConstantFolding));
        }
      } else {
        compiledInputs.push_back(compileExpression(
            input,
            scope,
            config,
            pool,
            flatteningCandidates,
            enableConstantFolding));
      }
    }
  }
  return compiledInputs;
}

std::vector<TypePtr> getTypes(const std::vector<ExprPtr>& exprs) {
  std::vector<TypePtr> types;
  types.reserve(exprs.size());
  for (auto& expr : exprs) {
    types.emplace_back(expr->type());
  }
  return types;