rename "non-value" to "error-or-stopped"

Summary: See predecessor D91389724.

Reviewed By: ispeters

Differential Revision: D91389725

fbshipit-source-id: 02c5116c735273a7ac091250efc7b66c2d43dd22

Author: snarkmaster

folly/result/test/enrich_non_value_bench.cpp

@@ -39,7 +39,7 @@ FOLLY_ALWAYS_INLINE void bench_enrich_non_value(size_t iters, EnrichFn&& fn) {
     for (size_t i = 0; i < iters; ++i) {
       // An immortal avoids measuring the cost of dynamic `std::exception_ptr`
       // for the base error -- otherwise, the baseline would be closer to 50ns.
-      auto enriched = fn(non_value_result{immortal_rich_error<BenchErr>});
+      auto enriched = fn(error_or_stopped{immortal_rich_error<BenchErr>});
       folly::compiler_must_not_predict(enriched);
       numOkay += nullptr !=
           std::move(enriched)
@@ -51,29 +51,29 @@ FOLLY_ALWAYS_INLINE void bench_enrich_non_value(size_t iters, EnrichFn&& fn) {
 }
 
 BENCHMARK(non_enriched_baseline, n) {
-  bench_enrich_non_value<BenchErr>(n, [](non_value_result&& nvr) {
-    return std::move(nvr);
+  bench_enrich_non_value<BenchErr>(n, [](error_or_stopped&& eos) {
+    return std::move(eos);
   });
 }
 
 BENCHMARK(enrich_non_value_location_only, n) {
   bench_enrich_non_value<detail::enriched_non_value>(
       n,
-      [](non_value_result&& nvr) { return enrich_non_value(std::move(nvr)); });
+      [](error_or_stopped&& eos) { return enrich_non_value(std::move(eos)); });
 }
 
 BENCHMARK(enrich_non_value_location_plus_static_message, n) {
   bench_enrich_non_value<detail::enriched_non_value>(
-      n, [](non_value_result&& nvr) {
-        return enrich_non_value(std::move(nvr), "context");
+      n, [](error_or_stopped&& eos) {
+        return enrich_non_value(std::move(eos), "context");
       });
 }
 
 BENCHMARK(enrich_non_value_location_plus_formatted_message, n) {
   int value = 42;
   bench_enrich_non_value<detail::enriched_non_value>(
-      n, [&](non_value_result&& nvr) {
-        return enrich_non_value(std::move(nvr), "value={}", value);
+      n, [&](error_or_stopped&& eos) {
+        return enrich_non_value(std::move(eos), "value={}", value);
       });
 }
 

folly/result/test/enrich_non_value_test.cpp

@@ -59,23 +59,23 @@ TEST(RichErrorBaseFormatTest, SameErrorDirectThenUnderlying2) {
 TEST(EnrichNonValueTest, accessEnrichedAndUnderlyingException) {
   std::string bare_msg = "folly::TinyErr";
 
-  auto assertUnderlying = [&](auto& nvr, const std::string& re) {
+  auto assertUnderlying = [&](auto& eos, const std::string& re) {
     {
       // Only `rich_exception_ptr` can show the enrichment info AND expose the
       // underlying exception.  By converting to a bare `exception_ptr`, we
       // discard the enrichment chain.
-      auto eptr = copy(nvr).to_exception_ptr_slow();
+      auto eptr = copy(eos).to_exception_ptr_slow();
       EXPECT_EQ(bare_msg, fmt::format("{}", *get_rich_error(eptr)));
       EXPECT_FALSE(get_exception<detail::enriched_non_value>(eptr));
       EXPECT_TRUE(get_exception<TinyErr>(eptr));
       EXPECT_TRUE(get_exception<rich_error<TinyErr>>(eptr));
     }
-    checkFormatViaGet<TinyErr, rich_error_base, std::exception>(nvr, re);
+    checkFormatViaGet<TinyErr, rich_error_base, std::exception>(eos, re);
 
     // Enrichment is transparent: although `enriched_non_value` is itself a
     // `rich_error_base`, all public APIs (except `get_outer_exception()` go to
     // the underlying error.
-    auto rex = get_rich_error(nvr);
+    auto rex = get_rich_error(eos);
     EXPECT_FALSE(dynamic_cast<const detail::enriched_non_value*>(rex.get()));
     EXPECT_TRUE(dynamic_cast<const TinyErr*>(rex.get()));
     EXPECT_TRUE(dynamic_cast<const rich_error<TinyErr>*>(rex.get()));
@@ -92,13 +92,13 @@ TEST(EnrichNonValueTest, accessEnrichedAndUnderlyingException) {
     EXPECT_TRUE(std::nullopt == get_rich_error_code<A1>(*rex));
   };
 
-  non_value_result nvr0{rich_error<TinyErr>{}};
-  const auto* innerErr = get_exception<TinyErr>(nvr0).get();
+  error_or_stopped eos0{rich_error<TinyErr>{}};
+  const auto* innerErr = get_exception<TinyErr>(eos0).get();
 
   // Cover the "outer" `rich_error_base` interface (except codes)
-  auto assertOuter = [&](auto& nvr, int err_line, const char* msg = "") {
+  auto assertOuter = [&](auto& eos, int err_line, const char* msg = "") {
     auto& outer =
-        *std::move(nvr)
+        *std::move(eos)
              .release_rich_exception_ptr()
              .template get_outer_exception<detail::enriched_non_value>();
     EXPECT_EQ(err_line, outer.source_location().line());
@@ -112,19 +112,19 @@ TEST(EnrichNonValueTest, accessEnrichedAndUnderlyingException) {
 
   // Add and test 1 enrichment
   auto err_line1 = source_location::current().line() + 1;
-  auto nvr1 = enrich_non_value(std::move(nvr0));
+  auto eos1 = enrich_non_value(std::move(eos0));
 
-  assertOuter(nvr1, err_line1);
+  assertOuter(eos1, err_line1);
   assertUnderlying(
-      nvr1,
+      eos1,
       fmt::format("{} \\[via\\] {}:{}", bare_msg, test_file_name, err_line1));
 
   // Wrap a second enrichment to ensure skip-to-underlying, not skip-to-next
   auto err_line2 = source_location::current().line() + 1;
-  auto nvr2 = enrich_non_value(std::move(nvr1), "literal");
-  assertOuter(nvr2, err_line2, "literal");
+  auto eos2 = enrich_non_value(std::move(eos1), "literal");
+  assertOuter(eos2, err_line2, "literal");
   assertUnderlying(
-      nvr2,
+      eos2,
       fmt::format(
           "{} \\[via\\] literal @ {}:{} \\[after\\] {}:{}",
           bare_msg,
@@ -136,17 +136,17 @@ TEST(EnrichNonValueTest, accessEnrichedAndUnderlyingException) {
 
 // The underlying error doesn't have to be a `rich_error_base`.
 TEST(EnrichNonValueTest, enrichPlainError) {
-  auto nvr = enrich_non_value(
+  auto eos = enrich_non_value(
       enrich_non_value(
-          enrich_non_value(non_value_result{std::logic_error{"inner"}}), "msg"),
+          enrich_non_value(error_or_stopped{std::logic_error{"inner"}}), "msg"),
       "format{}",
       std::string{"ted"});
 
   // `get_exception` makes a `logic_error*` quack-alike with rich formatting
-  const std::logic_error* ex{get_exception<std::logic_error>(nvr)};
+  const std::logic_error* ex{get_exception<std::logic_error>(eos)};
   EXPECT_STREQ("inner", ex->what());
   checkFormatViaGet<std::logic_error, std::exception>(
-      nvr,
+      eos,
       fmt::format(
           "std::logic_error: inner \\[via\\] formatted @ {}:[0-9]+ \\[after\\] "
           "msg @ {}:[0-9]+ \\[after\\] {}:[0-9]+",
@@ -180,7 +180,7 @@ TEST(EnrichNonValueTest, enrichResultWithValue) {
 // Add enrichment to a non-value `result`
 TEST(EnrichNonValueTest, enrichResultWithNonValue) {
   auto r = enrich_non_value(
-      result<int>{non_value_result{std::logic_error{"inner"}}}, "msg");
+      result<int>{error_or_stopped{std::logic_error{"inner"}}}, "msg");
   static_assert(std::same_as<result<int>, decltype(r)>);
   EXPECT_FALSE(r.has_value());
 
@@ -195,8 +195,8 @@ TEST(EnrichNonValueTest, enrichResultWithNonValue) {
 
 // Codes are forwarded to the underlying error, and formatted.
 TEST(EnrichNonValueTest, retrieveCodeDelegatesToUnderlying) {
-  auto nvr = enrich_non_value(
-      enrich_non_value(non_value_result{make_coded_rich_error(A1::ONE_A1)}));
+  auto eos = enrich_non_value(
+      enrich_non_value(error_or_stopped{make_coded_rich_error(A1::ONE_A1)}));
 
   // If we insist on inspecting the outer error (I'm not seeing how this would
   // happen in normal usage), it has no code. Yes, we could easily forward the
@@ -205,16 +205,16 @@ TEST(EnrichNonValueTest, retrieveCodeDelegatesToUnderlying) {
   EXPECT_EQ(
       std::nullopt,
       get_rich_error_code<A1>(
-          *copy(nvr)
+          *copy(eos)
                .release_rich_exception_ptr()
                .get_outer_exception<detail::enriched_non_value>()));
 
   // Normal access first resolves the underlying error, so code access works.
-  EXPECT_EQ(A1::ONE_A1, get_rich_error_code<A1>(nvr));
+  EXPECT_EQ(A1::ONE_A1, get_rich_error_code<A1>(eos));
 
   // The `get_exception` pointer has enriched formatting, including the code.
   checkFormatViaGet<coded_rich_error<A1>, rich_error_base, std::exception>(
-      nvr,
+      eos,
       fmt::format(
           "A1=1 @ {}:[0-9]+ \\[via\\] {}:[0-9]+ \\[after\\] {}:[0-9]+",
           test_file_name,

folly/result/test/or_unwind_rich_test.cpp

@@ -50,25 +50,25 @@ TEST(OrUnwindRich, error) {
         "std::logic_error: {} @ {}:{}", msgViaCtx, test_file_name, err_line);
   };
 
-  checkEnrichedError( // `result` in non-value state
+  checkEnrichedError( // `result` in error-or-stopped state
     [&]() -> result<> {
-      result<int> r{non_value_result{std::logic_error{"err1"}}};
+      result<int> r{error_or_stopped{std::logic_error{"err1"}}};
       err_line = std::source_location::current().line() + 1;
       (void)co_await or_unwind_rich(std::move(r), "ctx1");
     }(),
     expectedMsg("err1 [via] ctx1"));
 
-  checkEnrichedError( // `non_value_result`
+  checkEnrichedError( // `error_or_stopped`
     [&]() -> result<> {
-      non_value_result nvr{std::logic_error{"err2"}};
+      error_or_stopped eos{std::logic_error{"err2"}};
       err_line = std::source_location::current().line() + 1;
-      co_await or_unwind_rich(std::move(nvr), "ctx2");
+      co_await or_unwind_rich(std::move(eos), "ctx2");
     }(),
     expectedMsg("err2 [via] ctx2"));
 
   checkEnrichedError( // `result` with format args
     [&]() -> result<> {
-      result<int> r{non_value_result{std::logic_error{"err3"}}};
+      result<int> r{error_or_stopped{std::logic_error{"err3"}}};
       err_line = std::source_location::current().line() + 1;
       (void)co_await or_unwind_rich(std::move(r), "x={} y={}", 10, 20);
     }(),
@@ -85,9 +85,9 @@ TEST(OrUnwindRich, stopped) {
   EXPECT_TRUE(res.has_stopped());
   auto msg = "folly::OperationCancelled: coroutine operation cancelled";
   // Temporary workaround for `static_assert` against testing for OC in
-  // `result.h`.  Future: Once `result` or `non_value_result` is formattable,
+  // `result.h`.  Future: Once `result` or `error_or_stopped` is formattable,
   // we can avoid this hackery.
-  auto rep = std::move(res).non_value().release_rich_exception_ptr();
+  auto rep = std::move(res).error_or_stopped().release_rich_exception_ptr();
   EXPECT_EQ(
       fmt::format("{} [via] ctx @ {}:{}", msg, test_file_name, err_line),
       fmt::format("{}", get_exception<OperationCancelled>(rep)));

folly/result/test/or_unwind_test.cpp

@@ -29,7 +29,7 @@
 // - Awaiter: `or_unwind` (&, const&, &&), `or_unwind_owning`
 // - Context: `result` coroutine, `now_task` coroutine
 // - Inner type: `void`, `int` and refs, `string`, `unique_ptr` and refs
-// - Result-like container: `result`, `value_only_result`, `non_value_result`
+// - Result-like container: `result`, `value_only_result`, `error_or_stopped`
 // - States: value, error, stopped
 
 #if FOLLY_HAS_RESULT
@@ -90,7 +90,8 @@ consteval void checkAwaitResumeType() {
           decltype(std::declval<Awaitable>().await_resume())>);
 }
 
-// Check `await_resume()` types for rvalue-only types (e.g. `non_value_result`).
+// Check `await_resume()` types for rvalue-only types (e.g.
+// `error_or_stopped`).
 template <typename ResultT, typename RvalueT, typename OwningT>
 consteval void checkRvalueAwaitResumeTypes() {
   checkAwaitResumeType<RvalueT, decltype(or_unwind(FOLLY_DECLVAL(ResultT)))>();
@@ -150,9 +151,9 @@ ResultT makeResultWithValue(MakeInner&& makeInner) {
   }
 }
 
-// An empty `non_value_result` made from an empty `exception_wrapper`.
-inline non_value_result emptyNonValue() {
-  return non_value_result::make_legacy_error_or_cancellation_slow(
+// An empty `error_or_stopped` made from an empty `exception_wrapper`.
+inline error_or_stopped emptyErrorOrStopped() {
+  return error_or_stopped::make_legacy_error_or_cancellation_slow(
       detail::result_private_t{}, exception_wrapper{});
 }
 
@@ -170,16 +171,17 @@ void forEachOrUnwindVariant(MakeResult makeResult, Check&& check) {
     check(tag_t<Context>{}, or_unwind(std::as_const(val)));
     // Lvalue refs must NOT mutate the original (error is copied, not moved).
     // Users don't expect `co_await or_unwind(r)` to mutate `r`.
-    if constexpr (requires { val.non_value(); }) {
-      EXPECT_TRUE(hasValue || (emptyNonValue() != val.non_value()));
+    if constexpr (requires { val.error_or_stopped(); }) {
+      EXPECT_TRUE(
+          hasValue || (emptyErrorOrStopped() != val.error_or_stopped()));
     }
   }
   check(tag_t<Context>{}, or_unwind_owning(makeResult()));
   // By rvalue ref -- error SHOULD be moved out.
   check(tag_t<Context>{}, or_unwind(std::move(val)));
-  if constexpr (requires { val.non_value(); }) {
+  if constexpr (requires { val.error_or_stopped(); }) {
     // NOLINTNEXTLINE(bugprone-use-after-move)
-    EXPECT_TRUE(hasValue || (emptyNonValue() == val.non_value()));
+    EXPECT_TRUE(hasValue || (emptyErrorOrStopped() == val.error_or_stopped()));
   }
 }
 
@@ -220,19 +222,19 @@ struct CheckExtractRef {
   }
 };
 
-// Test non-value propagation across all applicable variants.
-template <typename MakeNonValue, typename Verify>
-void testNonValue(MakeNonValue makeNonValue, Verify verify) {
+// Test error-or-stopped propagation across all applicable variants.
+template <typename MakeErrorOrStopped, typename Verify>
+void testErrorOrStopped(MakeErrorOrStopped makeErrorOrStopped, Verify verify) {
   forEachOrUnwindVariant<InResult>(
-      makeNonValue, [&](tag_t<InResult>, auto&& awaitable) {
+      makeErrorOrStopped, [&](tag_t<InResult>, auto&& awaitable) {
         auto out = InResult::run([&]() -> InResult::Coro<void> {
           (void)co_await must_use_immediately_unsafe_mover(
               static_cast<decltype(awaitable)>(awaitable))();
         });
         verify(out);
       });
   forEachOrUnwindVariant<InTask>(
-      makeNonValue, [&](tag_t<InTask>, auto&& awaitable) {
+      makeErrorOrStopped, [&](tag_t<InTask>, auto&& awaitable) {
         auto out = InTask::run([&]() -> InTask::Coro<void> {
           (void)co_await must_use_immediately_unsafe_mover(
               static_cast<decltype(awaitable)>(awaitable))();
@@ -242,18 +244,18 @@ void testNonValue(MakeNonValue makeNonValue, Verify verify) {
 }
 
 template <typename... Makes>
-void testNonValueErrors(Makes... makes) {
+void testErrorOrStoppedErrors(Makes... makes) {
   auto verify = [](auto& out) {
     EXPECT_TRUE(!out.has_value() && !out.has_stopped());
     EXPECT_NE(nullptr, get_exception<std::runtime_error>(out));
   };
-  (testNonValue(makes, verify), ...);
+  (testErrorOrStopped(makes, verify), ...);
 }
 
 template <typename... Makes>
-void testNonValueStopped(Makes... makes) {
+void testErrorOrStoppedStopped(Makes... makes) {
   auto verify = [](auto& out) { EXPECT_TRUE(out.has_stopped()); };
-  (testNonValue(makes, verify), ...);
+  (testErrorOrStopped(makes, verify), ...);
 }
 
 // Test all `or_unwind...` flavors in both `result` and `now_task` coros.
@@ -278,12 +280,12 @@ void testOrUnwind(MakeInner makeInner, const CheckValue& checkValue) {
     forEachOrUnwindVariant<InTask>(makeRes, checkValue);
   }
 
-  // Propagate error/stopped, for result types with `.non_value()`
-  if constexpr (requires { FOLLY_DECLVAL(ResultT).non_value(); }) {
-    testNonValueErrors([&] {
-      return ResultT{non_value_result{std::runtime_error{"err"}}};
+  // Propagate error/stopped, for result types with `.error_or_stopped()`
+  if constexpr (requires { FOLLY_DECLVAL(ResultT).error_or_stopped(); }) {
+    testErrorOrStoppedErrors([&] {
+      return ResultT{error_or_stopped{std::runtime_error{"err"}}};
     });
-    testNonValueStopped([&] { return ResultT{stopped_result}; });
+    testErrorOrStoppedStopped([&] { return ResultT{stopped_result}; });
   }
 }
 
@@ -339,16 +341,16 @@ TEST(OrUnwind, valueOnlyResult) {
   testOrUnwindVaryingInnerType<value_only_result>();
 }
 
-// Test `or_unwind...` overloads for `non_value_result` & `stopped_result_t`
-TEST(OrUnwind, nonValueResult) {
-  checkRvalueAwaitResumeTypes<non_value_result, void, void>();
+// Test `or_unwind...` overloads for `error_or_stopped` & `stopped_result_t`
+TEST(OrUnwind, errorOrStoppedResult) {
+  checkRvalueAwaitResumeTypes<error_or_stopped, void, void>();
   checkRvalueAwaitResumeTypes<stopped_result_t, void, void>();
 
-  testNonValueErrors([] {
-    return non_value_result{std::runtime_error{"err"}};
+  testErrorOrStoppedErrors([] {
+    return error_or_stopped{std::runtime_error{"err"}};
   });
-  testNonValueStopped(
-      [] { return non_value_result{stopped_result}; },
+  testErrorOrStoppedStopped(
+      [] { return error_or_stopped{stopped_result}; },
       [] { return stopped_result; });
 }