Method CreateTraceableProgram

runtime/internal/runtime_impl.cc:127–153

}

absl::StatusOr<std::unique_ptr<TraceableProgram>>
RuntimeImpl::CreateTraceableProgram(
    std::unique_ptr<Ast> ast,
    const Runtime::CreateProgramOptions& options) const {
  CEL_ASSIGN_OR_RETURN(auto flat_expr, expr_builder_.CreateExpressionImpl(
                                           std::move(ast), options.issues));

  // Special case if the program is fully recursive.
  //
  // This implementation avoids unnecessary allocs at evaluation time which
  // improves performance notably for small expressions.
  if (expr_builder_.options().max_recursion_depth != 0 &&
      !flat_expr.subexpressions().empty() &&
      // mainline expression is exactly one recursive step.
      flat_expr.subexpressions().front().size() == 1 &&
      flat_expr.subexpressions().front().front()->GetNativeTypeId() ==
          NativeTypeId::For<WrappedDirectStep>()) {
    const DirectExpressionStep* root =
        internal::down_cast<const WrappedDirectStep*>(
            flat_expr.subexpressions().front().front().get())
            ->wrapped();
    return std::make_unique<RecursiveProgramImpl>(environment_,
                                                  std::move(flat_expr), root);
  }

  return std::make_unique<ProgramImpl>(environment_, std::move(flat_expr));
}

bool TestOnly_IsRecursiveImpl(const Program* program) {
  return dynamic_cast<const RecursiveProgramImpl*>(program) != nullptr;