Replaced std::exit() with return Carbon::ErrorOr for expected errors like invalid syntax (#1120)

* Replaced std::exit() with return llvm::Expected/llvm::Error<T> for expected errors like invalid syntax. * Use llvm::formatv() for formatting lexer error messages. x * Addresed merge errors. * Fixed impl scope. * Made ErrorBuilder::operator<< nodiscard, to catch code forgetting 'return' in 'return FATAL_COMPILATION_ERROR()'. * FatalComplationError() -> ParseAndLexContext::RecordLexerError(). Other usages of ERROR_TOKEN in lexer.lpp were actually supposed to be END_OF_FILE. * Update executable_semantics/syntax/parse_and_lex_context.h Co-authored-by: Jon Meow <jperkins@google.com> * Code review fixes. * Update executable_semantics/syntax/parser.ypp Co-authored-by: Jon Meow <jperkins@google.com> * More code review fixes. * Update executable_semantics/interpreter/type_checker.h Co-authored-by: Jon Meow <jperkins@google.com> * Yet more code review fixes... * Update executable_semantics/syntax/lexer.lpp Co-authored-by: Jon Meow <jperkins@google.com> * code review comments * Update executable_semantics/interpreter/interpreter.cpp Co-authored-by: Geoff Romer <gromer@google.com> * Apply suggestions from code review Co-authored-by: Jon Meow <jperkins@google.com> * Update executable_semantics/syntax/lexer.lpp Co-authored-by: Jon Meow <jperkins@google.com> * code review * code review * Apply suggestions from code review Co-authored-by: Jon Meow <jperkins@google.com> * formatted code * review comments * Switched to the new ErrorOr<V> error implementation * code review comments * fixed comment * restored ostream.h as #976 makes the change unnecesary * review comments Co-authored-by: Jon Meow <jperkins@google.com> Co-authored-by: Geoff Romer <gromer@google.com>
2026-09-28 09:40:13 +01:00 · 2022-03-22 16:17:04 -04:00
parent e5a87af6fe
commit aa8a5f174d
43 changed files with 1324 additions and 873 deletions
@@ -9,24 +9,94 @@
 namespace Carbon::Testing {
 namespace {

+using ::testing::Eq;
+
+auto MakeSuccess() -> ErrorOr<Success> { return Success(); }
+
+auto MakeError(std::string_view message) -> ErrorOr<Success> {
+  return Error(message);
+}
+
+auto MakeInt(int value) -> ErrorOr<int> { return value; }
+
+auto MakeFailedInt(std::string_view message) -> ErrorOr<int> {
+  return Error(message);
+}
+
+auto ErrorToString(const Error& e) -> std::string { return e.message(); }
+
+template <typename V>
+auto ErrorToString(const ErrorOr<V>& e) -> std::string {
+  return e.error().message();
+}
+
 TEST(ErrorTest, FatalProgramError) {
-  ASSERT_DEATH({ FATAL_PROGRAM_ERROR_NO_LINE() << "test"; },
-               "^PROGRAM ERROR: test\n");
+  EXPECT_EQ(ErrorToString(FATAL_PROGRAM_ERROR_NO_LINE() << "test"),
+            "PROGRAM ERROR: test");
 }

 TEST(ErrorTest, FatalRuntimeError) {
-  ASSERT_DEATH({ FATAL_RUNTIME_ERROR_NO_LINE() << "test"; },
-               "^RUNTIME ERROR: test\n");
+  EXPECT_EQ(ErrorToString(FATAL_RUNTIME_ERROR_NO_LINE() << "test"),
+            "RUNTIME ERROR: test");
 }

 TEST(ErrorTest, FatalCompilationError) {
-  ASSERT_DEATH({ FATAL_COMPILATION_ERROR_NO_LINE() << "test"; },
-               "^COMPILATION ERROR: test\n");
+  EXPECT_EQ(ErrorToString(FATAL_COMPILATION_ERROR_NO_LINE() << "test"),
+            "COMPILATION ERROR: test");
 }

 TEST(ErrorTest, FatalProgramErrorLine) {
-  ASSERT_DEATH({ FATAL_PROGRAM_ERROR(1) << "test"; },
-               "^PROGRAM ERROR: 1: test\n");
+  EXPECT_EQ(ErrorToString(FATAL_PROGRAM_ERROR(1) << "test"),
+            "PROGRAM ERROR: 1: test");
+}
+
+TEST(ErrorTest, ReturnIfErrorNoError) {
+  auto result = []() -> ErrorOr<Success> {
+    RETURN_IF_ERROR(MakeSuccess());
+    RETURN_IF_ERROR(MakeSuccess());
+    return Success();
+  }();
+  EXPECT_TRUE(result.ok());
+}
+
+TEST(ErrorTest, ReturnIfErrorHasError) {
+  auto result = []() -> ErrorOr<Success> {
+    RETURN_IF_ERROR(MakeSuccess());
+    RETURN_IF_ERROR(MakeError("error"));
+    return Success();
+  }();
+  ASSERT_FALSE(result.ok());
+  EXPECT_EQ(ErrorToString(result), "error");
+}
+
+TEST(ErrorTest, AssignOrReturnNoError) {
+  auto result = []() -> ErrorOr<int> {
+    RETURN_IF_ERROR(MakeSuccess());
+    ASSIGN_OR_RETURN(int a, MakeInt(1));
+    ASSIGN_OR_RETURN(const int b, MakeInt(2));
+    int c = 0;
+    ASSIGN_OR_RETURN(c, MakeInt(3));
+    return a + b + c;
+  }();
+  ASSERT_TRUE(result.ok());
+  EXPECT_EQ(6, *result);
+}
+
+TEST(ErrorTest, AssignOrReturnHasDirectError) {
+  auto result = []() -> ErrorOr<int> {
+    RETURN_IF_ERROR(MakeError("error"));
+    return 0;
+  }();
+  ASSERT_FALSE(result.ok());
+}
+
+TEST(ErrorTest, AssignOrReturnHasErrorInExpected) {
+  auto result = []() -> ErrorOr<int> {
+    ASSIGN_OR_RETURN(int a, MakeFailedInt("error"));
+    return a;
+  }();
+  ASSERT_FALSE(result.ok());
+  EXPECT_EQ(ErrorToString(result), "error");
 }

 }  // namespace