Fix weirdly apologetic diagnostic messages

[AryanGodara]

Summary

Signed-off-by: aryan <[e-mail]>

Resolves https://github.com/llvm/llvm-project/issues/61256

The aim of the patch is to make the error logs less verbose and apologetic, and stick mainly to explain the issue in minimum words.

[mehdi_amini]

You should look into the title and description of the commit: https://cbea.ms/git-commit/

[DavidSpickett]

Is there some standard for writing warning messages? For llvm that is, it would be worth looking through the getting started guides to see. I think the majority of warnings are "formal" in that sense so this seems fine.

Personally I agree with making the warnings more succinct but aside from that I don't see the need to change comments or testing scripts.

You may consider splitting this change into 2. One that only changes warnings and errors (a less controversial change) and the rest (that is up to the reviewers of each bit).

clang/test/SemaTemplate/temp_arg_nontype_cxx20.cpp

51

Please find out what the {{sorry}} here was for. Did someone literally write it as an apology, or is it indicating some warning that should be emitted here, if the FIXME is fixed?

You could git blame this file and find the commit that introduced it, as a starting point.

polly/lib/External/isl/imath/tests/test.sh

12

Given that this is a developer facing script, I think the "did you build it" is in fact quite useful here. Perhaps it could say:
"The imath test driver 'imtest' was not found. Did you build it? It is required for running the tests."

[DavidSpickett]

Ah, here it is: https://llvm.org/docs/CodingStandards.html#error-and-warning-messages

Seems to back you up.

[junaire]

I'm not certain if it's bad to say 'sorry', IMHO it's fine?

Anyway, you can't just simply delete those words (in diagnostic messages and regression tests), that doesn't work. To verify the patch is good, you can run ninja check-all to make sure the testsuite passes.

[AryanGodara]

In D146041#4192816, @mehdi_amini wrote:

You should look into the title and description of the commit: https://cbea.ms/git-commit/

Is the title and description appropriate now?
I can add more details to the description, as required

[AryanGodara]

In D146041#4193045, @DavidSpickett wrote:

Is there some standard for writing warning messages? For llvm that is, it would be worth looking through the getting started guides to see. I think the majority of warnings are "formal" in that sense so this seems fine.

Personally I agree with making the warnings more succinct but aside from that I don't see the need to change comments or testing scripts.

You may consider splitting this change into 2. One that only changes warnings and errors (a less controversial change) and the rest (that is up to the reviewers of each bit).

I will do go through the changes I made, and first make sure to change only warnings and errors.

Since this is my first commit to such a large repository(and project), can you please guide me with this @DavidSpickett !

[AryanGodara]

In D146041#4193172, @junaire wrote:

I'm not certain if it's bad to say 'sorry', IMHO it's fine?

Anyway, you can't just simply delete those words (in diagnostic messages and regression tests), that doesn't work. To verify the patch is good, you can run ninja check-all to make sure the testsuite passes.

This was one of the issues for Outreachy '23, and I asked my outreachy mentor to work on this issue.
I'm looking for any help to make the patch more meaningful, and get guidance along the way.

I'll run ninja check-all, before pushing the next commit for revision.

[DavidSpickett]

Since this is my first commit to such a large repository(and project), can you please guide me with this @DavidSpickett !

Sure, you'll want to make a commit that only has changes to warnings and errors. You can split up this one to do that, see part "A)" of this answer https://stackoverflow.com/questions/6217156/break-a-previous-commit-into-multiple-commits/6217314#6217314. Then you can update this review with that new commit, change the description/title etc. if needed.

If you get confused with updating the review (happens to me all the time) you can just abandon this (there is an entry in the "Add Action..." menu) and make a new review as you did before.

How to identify what changes should be included? I would ignore comments, shell scripts, FIXMEs, or general test data. If the test is producing a warning and looking for it, clearly it should be changed. If it's just random data it's using to test some function, I wouldn't change it.

[AryanGodara]

In D146041#4195992, @DavidSpickett wrote:

Since this is my first commit to such a large repository(and project), can you please guide me with this @DavidSpickett !

Sure, you'll want to make a commit that only has changes to warnings and errors. You can split up this one to do that, see part "A)" of this answer https://stackoverflow.com/questions/6217156/break-a-previous-commit-into-multiple-commits/6217314#6217314. Then you can update this review with that new commit, change the description/title etc. if needed.

If you get confused with updating the review (happens to me all the time) you can just abandon this (there is an entry in the "Add Action..." menu) and make a new review as you did before.

How to identify what changes should be included? I would ignore comments, shell scripts, FIXMEs, or general test data. If the test is producing a warning and looking for it, clearly it should be changed. If it's just random data it's using to test some function, I wouldn't change it.

Thanks for the info @DavidSpickett !!
I will try to split this commit, and update on this asap (Sorry for the late update, I have mid-sem exams going on, I haven't abandoned this issue, still working on it).

[aaron.ballman]

In D146041#4198056, @AryanGodara wrote:

I will try to split this commit, and update on this asap (Sorry for the late update, I have mid-sem exams going on, I haven't abandoned this issue, still working on it).

No worries about the speed of updates, it's totally fine for weeks to pass between updates to a patch. We're usually pretty good at asking "is this abandoned" rather than assuming. FWIW, it looks like there's also precommit CI failures related to the changes that should be looked into.

clang/unittests/Format/FormatTest.cpp

11426

These changes don't really do much -- it's a test case, so the wording is not important, but what is important is retaining the string argument that is being dropped. I'd roll back the changes to this file.

[rsmith]

I have no strong opinions on the merits of this patch in either direction; I think the "sorry"s in the Sema diagnostics for regrettable non-conformance make Clang marginally friendlier, but they do nothing to actually help people who encounter the diagnostic.

FWIW, the relevant guidance on Clang diagnostics is https://clang.llvm.org/docs/InternalsManual.html#the-format-string, and that would override the LLVM coding guidelines' rules in places where they conflict (though in this case there's no conflict).

clang/include/clang/Basic/DiagnosticCommonKinds.td

338

I think we could drop the "unsupported: " here too. (We're allowed to have implementation limits; this isn't a conformance issue.)

341

Please remove the trailing period while you're fixing the style of this diagnostic.

clang/include/clang/Basic/DiagnosticSemaKinds.td

9669

While we're fixing style: in this file we have "is not yet supported", "is not supported yet", and "is not supported". We should pick one and use it consistently; "is not supported yet" would be my preference.

clang/test/SemaTemplate/temp_arg_nontype_cxx20.cpp

11–12

You should retain a {{...}} here with some text from the diagnostic for -verify to match against. Likewise below.

[ipriyanshi1708]

Hi @AryanGodara , I am an Outreachy applicant. I was also working on this issue and also created a patch for this issue i.e., https://reviews.llvm.org/D146530 . Can we collaborate to solve this issue so that only one patch will be there for a issue as told by @aaron.ballman .

[manas]

Hi, I came across this due to changes in Static Analyzer. One of the changes is not related to the Github issue mentioned above. Maybe we can drop that file?

clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp

1214–1215

This is unrelated to the above mentioned issue.

clang/include/clang/Basic/DiagnosticCommonKinds.td

 def err_invalid_feature_combination : Error<
   "invalid feature combination: %0">;
 
 // Source manager
 def err_cannot_open_file : Error<"cannot open file '%0': %1">, DefaultFatal;
 def err_file_modified : Error<
   "file '%0' modified since it was first processed">, DefaultFatal;
 def err_file_too_large : Error<
-  "sorry, unsupported: file '%0' is too large for Clang to process">;
+  "unsupported: file '%0' is too large for Clang to process">;
 def err_include_too_large : Error<
-  "sorry, this include generates a translation unit too large for"
+  "this include generates a translation unit too large for"
   " Clang to process.">, DefaultFatal;
 def err_unsupported_bom : Error<"%0 byte order mark detected in '%1', but "
   "encoding is not supported">, DefaultFatal;
 def err_unable_to_rename_temp : Error<
   "unable to rename temporary '%0' to output file '%1': '%2'">;
 def err_unable_to_make_temp : Error<
   "unable to make temporary file: %0">;
 def remark_sloc_usage : Remark<
   "source manager location address space usage:">,

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_deduced_non_type_template_arg_type_mismatch : Error<
   "deduced non-type template argument does not have the same type as the "
   "corresponding template parameter%diff{ ($ vs $)|}0,1">;
 def err_non_type_template_arg_subobject : Error<
   "non-type template argument refers to subobject '%0'">;
 def err_non_type_template_arg_addr_label_diff : Error<
   "template argument / label address difference / what did you expect?">;
 def err_non_type_template_arg_unsupported : Error<
-  "sorry, non-type template argument of type %0 is not yet supported">;
+  "non-type template argument of type %0 is not yet supported">;
 def err_template_arg_not_convertible : Error<
   "non-type template argument of type %0 cannot be converted to a value "
   "of type %1">;
 def warn_template_arg_negative : Warning<
   "non-type template argument with value '%0' converted to '%1' for unsigned "
   "template parameter of type %2">, InGroup<Conversion>, DefaultIgnore;
 def warn_template_arg_too_large : Warning<
   "non-type template argument value '%0' truncated to '%1' for "
def note_template_arg_internal_object : Note<
   "non-type template argument refers to %select{function|object}0 here">;
 def note_template_arg_refers_here : Note<
   "non-type template argument refers here">;
 def err_template_arg_not_object_or_func : Error<
   "non-type template argument does not refer to an object or function">;
 def err_template_arg_not_pointer_to_member_form : Error<
   "non-type template argument is not a pointer to member constant">;
 def err_template_arg_member_ptr_base_derived_not_supported : Error<
-  "sorry, non-type template argument of pointer-to-member type %1 that refers "
+  "non-type template argument of pointer-to-member type %1 that refers "
   "to member %q0 of a different class is not supported yet">;
 def err_template_arg_invalid : Error<
   "non-type template argument '%0' is invalid">;
 def ext_template_arg_extra_parens : ExtWarn<
   "address non-type template argument cannot be surrounded by parentheses">;
 def warn_cxx98_compat_template_arg_extra_parens : Warning<
   "redundant parentheses surrounding address non-type template argument are "
   "incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore;
def warn_dangling_lifetime_pointer : Warning<
   InGroup<DanglingGsl>;
 def warn_new_dangling_initializer_list : Warning<
   "array backing "
   "%select{initializer list subobject of the allocated object|"
   "the allocated initializer list}0 "
   "will be destroyed at the end of the full-expression">,
   InGroup<DanglingInitializerList>;
 def warn_unsupported_lifetime_extension : Warning<
-  "sorry, lifetime extension of "
+  "lifetime extension of "
   "%select{temporary|backing array of initializer list}0 created "
   "by aggregate initialization using default member initializer "
   "is not supported; lifetime of %select{temporary|backing array}0 "
   "will end at the end of the full-expression">, InGroup<Dangling>;
 
 // For non-floating point, expressions of the form x == x or x != x
 // should result in a warning, since these always evaluate to a constant.
 // Array comparisons have similar warnings
 def warn_comparison_always : Warning<
   "%select{self-|array }0comparison always evaluates to "
   "%select{a constant|true|false|'std::strong_ordering::equal'}1">,

clang/lib/Sema/SemaDeclAttr.cpp

if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
     IdentifierInfo *NDId = ND->getIdentifier();
     NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation());
     NewD->addAttr(
         AliasAttr::CreateImplicit(Context, NDId->getName(), W.getLocation()));
     NewD->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation(),
                                            AttributeCommonInfo::AS_Pragma));
     WeakTopLevelDecl.push_back(NewD);
     // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
-    // to insert Decl at TU scope, sorry.
+    // to insert Decl at TU scope.
     DeclContext *SavedContext = CurContext;
     CurContext = Context.getTranslationUnitDecl();
     NewD->setDeclContext(CurContext);
     NewD->setLexicalDeclContext(CurContext);
     PushOnScopeChains(NewD, S);
     CurContext = SavedContext;
   } else { // just add weak to existing
     ND->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation(),

clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp

for (const SummaryCase &Case : Summary.getCases()) {
     if (NewState && NewState != State) {
       if (Case.getNote().empty()) {
         const NoteTag *NT = nullptr;
         if (const auto *D = dyn_cast_or_null<FunctionDecl>(Call.getDecl()))
           NT = Case.getErrnoConstraint().describe(C, D->getNameAsString());
         C.addTransition(NewState, NT);
       } else {
         StringRef Note = Case.getNote();
         const NoteTag *Tag = C.getNoteTag(
-            // Sorry couldn't help myself.
             [Node, Note]() -> std::string {
               // Don't emit "Assuming..." note when we ended up
               // knowing in advance which branch is taken.
               return (Node->succ_size() > 1) ? Note.str() : "";
             },
             /*IsPrunable=*/true);
         C.addTransition(NewState, Tag);
       }
     } else if (NewState == State) {

clang/test/CXX/drs/dr16xx.cpp

#if __cplusplus < 201402L
     // expected-error@-2 {{binds to a temporary}}
 #endif
     const A &a = A(); // expected-note {{default member init}}
   };
   D1 d1 = {};
 #if __cplusplus < 201402L
     // expected-note@-2 {{first required here}}
 #else
-    // expected-warning-re@-4 {{sorry, lifetime extension {{.*}} not supported}}
+    // expected-warning-re@-4 {{lifetime extension {{.*}} not supported}}
 #endif
 
   struct D2 {
     const A &a = A(); // expected-note {{default member init}}
     D2() {} // expected-error {{binds to a temporary}}
   };
 
   struct D3 { // expected-error {{binds to a temporary}}

clang/test/Lexer/SourceLocationsOverflow.c

 // RUN: not %clang %s -S -o - 2>&1 | FileCheck %s
 // CHECK: In file included from {{.*}}SourceLocationsOverflow.c
-// CHECK-NEXT: inc1.h{{.*}}: fatal error: sorry, this include generates a translation unit too large for Clang to process.
+// CHECK-NEXT: inc1.h{{.*}}: fatal error: this include generates a translation unit too large for Clang to process.
 // CHECK-NEXT: #include "inc2.h"
 // CHECK-NEXT:          ^
 // CHECK-NEXT: note: 214{{.......}}B in local locations, 0B in locations loaded from AST files, for a total of 214{{.......}}B (99% of available space)
 // CHECK-NEXT: {{.*}}inc2.h:1:1: note: file entered 214{{..}} times using 214{{.......}}B of space
 // CHECK-NEXT: /*.................................................................................................
 // CHECK-NEXT: ^
 // CHECK-NEXT: {{.*}}inc1.h:1:1: note: file entered 15 times using 39{{....}}B of space
 // CHECK-NEXT: #include "inc2.h"

clang/test/SemaTemplate/temp_arg_nontype_cxx20.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++20 %s
 
 using size_t = __SIZE_TYPE__;
 
 namespace std {
   struct type_info;
 }
 
 // floating-point arguments
 template<float> struct Float {};
-using F1 = Float<1.0f>; // FIXME expected-error {{sorry}}
-using F1 = Float<2.0f / 2>; // FIXME expected-error {{sorry}}
+using F1 = Float<1.0f>; // FIXME expected-error
+using F1 = Float<2.0f / 2>; // FIXME expected-error
 
 struct S { int n[3]; } s; // expected-note 1+{{here}}
 union U { int a, b; } u;
 int n; // expected-note 1+{{here}}
 
 // pointers to subobjects
 template<int *> struct IntPtr {};
 using IPn = IntPtr<&n + 1>; // FIXME expected-error {{refers to subobject}}

 using S123 = Struct<S{1, 2, 4}>; // expected-error {{different types}}
 template<U> struct Union {};
 using U1 = Union<U{1}>;
 using U1 = Union<U{.a = 1}>; // expected-note {{previous}}
 using U1 = Union<U{.b = 1}>; // expected-error {{different types}}
 
 // miscellaneous scalar types
 template<_Complex int> struct ComplexInt {};
-using CI = ComplexInt<1 + 3i>; // FIXME: expected-error {{sorry}}
-using CI = ComplexInt<1 + 3i>; // FIXME: expected-error {{sorry}}
+using CI = ComplexInt<1 + 3i>; // FIXME: expected-error
+using CI = ComplexInt<1 + 3i>; // FIXME: expected-error
 
 template<_Complex float> struct ComplexFloat {};
-using CF = ComplexFloat<1.0f + 3.0fi>; // FIXME: expected-error {{sorry}}
-using CF = ComplexFloat<1.0f + 3.0fi>; // FIXME: expected-error {{sorry}}
+using CF = ComplexFloat<1.0f + 3.0fi>; // FIXME: expected-error
+using CF = ComplexFloat<1.0f + 3.0fi>; // FIXME: expected-error
 
 namespace ClassNTTP {
   struct A { // expected-note 2{{candidate}}
     int x, y;
   };
   template<A a> constexpr int f() { return a.y; }
   static_assert(f<A{1,2}>() == 2);
 

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, UnderstandsPointerQualifiersInCast) {
   verifyFormat("x = (foo * __unknown_qualifier) & v;");
 }
 
 TEST_F(FormatTest, UnderstandsSquareAttributes) {
   verifyFormat("SomeType s [[unused]] (InitValue);");
   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
-  verifyFormat("void f() [[deprecated(\"so sorry\")]];");
+  verifyFormat("void f() [[deprecated]];");
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
   verifyFormat("[[nodiscard]] bool f() { return false; }");
   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
-  verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
+  verifyFormat("class [[deprecated]] f {\npublic:\n  f() {}\n}");
   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
   verifyFormat("[[nodiscard]] ::qualified_type f();");
 
   // Make sure we do not mistake attributes for array subscripts.
   verifyFormat("int a() {}\n"
                "[[unused]] int b() {}\n");
   verifyFormat("NSArray *arr;\n"
                "arr[[Foo() bar]];");
EXPECT_EQ(FormatStyle::LK_ObjC,
                                    "#endif\n"));
 }
 
 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
   EXPECT_EQ(FormatStyle::LK_ObjC,
             guessLanguage("foo.h", "array[[calculator getIndex]];"));
   EXPECT_EQ(FormatStyle::LK_Cpp,
-            guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
+            guessLanguage("foo.h", "[[noreturn, deprecated]];"));
   EXPECT_EQ(
       FormatStyle::LK_Cpp,
-      guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
+      guessLanguage("foo.h", "[[noreturn, deprecated]];"));
   EXPECT_EQ(FormatStyle::LK_ObjC,
             guessLanguage("foo.h", "[[noreturn foo] bar];"));
   EXPECT_EQ(FormatStyle::LK_Cpp,
             guessLanguage("foo.h", "[[clang::fallthrough]];"));
   EXPECT_EQ(FormatStyle::LK_ObjC,
             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
   EXPECT_EQ(FormatStyle::LK_Cpp,
             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));

clang/www/demo/index.cgi

sub try_run {
 
     eval {
         local $SIG{ALRM} = sub { die "timeout"; };
         alarm $TIMEOUTAMOUNT;
         $retcode = system($commandline);
         alarm 0;
     };
     if ( $@ and $@ =~ /timeout/ ) { 
-      barf("Program $program took too long, compile time limited for the web script, sorry!\n"); 
+      barf("Program $program took too long, compile time limited for the web script.\n"); 
     }
     if ( -s $outputFile ) {
         print scalar dumpFile( "Output from $program", $outputFile );
     }
     #print "<p>Finished dumping command output.</p>\n";
     if ( WIFEXITED($retcode) && WEXITSTATUS($retcode) != 0 ) {
         barf(
 "$program exited with an error. Please correct source and resubmit.<p>\n" .
 "Please note that this form only allows fully formed and correct source" .
 " files.  It will not compile fragments of code.<p>"
         );
     }
     if ( WIFSIGNALED($retcode) != 0 ) {
         my $sig = WTERMSIG($retcode);
         barf(
-            "Ouch, $program caught signal $sig. Sorry, better luck next time!\n"
+            "Ouch, $program caught signal $sig.\n"
         );
     }
 }
 
 my %suffixes = (
     'Java'             => '.java',
     'JO99'             => '.jo9',
     'C'                => '.c',

lldb/examples/synthetic/libcxx.py

def get_child_at_index(self, index):
                 else:
                     # FIXME we need to have accessed item 0 before accessing
                     # any other item!
                     if self.skip_size is None:
                         logger >> "You asked for item > 0 before asking for item == 0, I will fetch 0 now then retry"
                         if self.get_child_at_index(0):
                             return self.get_child_at_index(index)
                         else:
-                            logger >> "item == 0 could not be found. sorry, nothing can be done here."
+                            logger >> "item == 0 could not be found. Nothing can be done here."
                             return None
                     return current.CreateChildAtOffset(
                         '[' + str(index) + ']', self.skip_size, self.data_type)
             else:
                 logger >> "Unable to infer data-type - returning None (should mark tree as garbage here?)"
                 return None
         except Exception as err:
             logger >> "Hit an exception: " + str(err)

llvm/include/llvm/CodeGen/MachinePassManager.h

private:
   std::enable_if_t<!is_detected<is_machine_module_pass_t, PassT>::value>
   addRunOnModule(PassConceptT *Pass) {}
 
   template <typename PassT>
   std::enable_if_t<is_detected<is_machine_module_pass_t, PassT>::value>
   addRunOnModule(PassConceptT *Pass) {
     static_assert(is_detected<is_machine_function_pass_t, PassT>::value,
                   "machine module pass needs to define machine function pass "
-                  "api. sorry.");
+                  "api.");
 
     using PassModelT =
         detail::PassModel<MachineFunction, PassT, PreservedAnalyses,
                           MachineFunctionAnalysisManager>;
     auto *P = static_cast<PassModelT *>(Pass);
     MachineModulePasses.emplace(
         Passes.size() - 1,
         [=](Module &M, MachineFunctionAnalysisManager &MFAM) {

llvm/tools/bugpoint/ExecutionDriver.cpp

case AutoPick:
     }
     if (!Interpreter) {
       InterpreterSel = RunLLI;
       Interpreter =
           AbstractInterpreter::createLLI(getToolName(), Message, &ToolArgv);
     }
     if (!Interpreter) {
       InterpreterSel = AutoPick;
-      Message = "Sorry, I can't automatically select an interpreter!\n";
+      Message = "I cannot automatically select an interpreter!\n";
     }
     break;
   case RunLLI:
     Interpreter =
         AbstractInterpreter::createLLI(getToolName(), Message, &ToolArgv);
     break;
   case RunLLC:
   case RunLLCIA:
case AutoPick:
     // In "llc-safe" mode, default to using LLC as the "safe" backend.
     if (InterpreterSel == RunLLC) {
       SafeInterpreterSel = RunLLC;
       SafeToolArgs.push_back("--relocation-model=pic");
       SafeInterpreter = AbstractInterpreter::createLLC(
           Path.c_str(), Message, CCBinary, &SafeToolArgs, &CCToolArgv);
     } else if (InterpreterSel != CompileCustom) {
       SafeInterpreterSel = AutoPick;
-      Message = "Sorry, I can't automatically select a safe interpreter!\n";
+      Message = "I cannot automatically select a safe interpreter!\n";
     }
     break;
   case RunLLC:
   case RunLLCIA:
     SafeToolArgs.push_back("--relocation-model=pic");
     SafeInterpreter = AbstractInterpreter::createLLC(
         Path.c_str(), Message, CCBinary, &SafeToolArgs, &CCToolArgv,
         SafeInterpreterSel == RunLLCIA);
     break;
   case Custom:
     SafeInterpreter = AbstractInterpreter::createCustomExecutor(
         getToolName(), Message, CustomExecCommand);
     break;
   default:
-    Message = "Sorry, this back-end is not supported by bugpoint as the "
+    Message = "This back-end is not supported by bugpoint as the "
               "\"safe\" backend right now!\n";
     break;
   }
   if (!SafeInterpreter && InterpreterSel != CompileCustom) {
     outs() << Message << "\nExiting.\n";
     exit(1);
   }
 

llvm/tools/bugpoint/ExtractFunction.cpp

BugDriver::deleteInstructionFromProgram(const Instruction *I,
   if (Simplification > 1 && !NoDCE)
     Passes.push_back("dce");
   if (Simplification && !DisableSimplifyCFG)
     Passes.push_back("simplifycfg"); // Delete dead control flow
 
   Passes.push_back("verify");
   std::unique_ptr<Module> New = runPassesOn(Clone.get(), Passes);
   if (!New) {
-    errs() << "Instruction removal failed.  Sorry. :(  Please report a bug!\n";
+    errs() << "Instruction removal failed. Please report a bug!\n";
     exit(1);
   }
   return New;
 }
 
 std::unique_ptr<Module>
 BugDriver::performFinalCleanups(std::unique_ptr<Module> M,
                                 bool MayModifySemantics) {
   // Make all functions external, so GlobalDCE doesn't delete them...
   for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
     I->setLinkage(GlobalValue::ExternalLinkage);
 
   std::vector<std::string> CleanupPasses;
 
   if (MayModifySemantics)
     CleanupPasses.push_back("deadarghaX0r");
   else
     CleanupPasses.push_back("deadargelim");
 
   std::unique_ptr<Module> New = runPassesOn(M.get(), CleanupPasses);
   if (!New) {
-    errs() << "Final cleanups failed.  Sorry. :(  Please report a bug!\n";
+    errs() << "Final cleanups failed. Please report a bug!\n";
     return nullptr;
   }
   return New;
 }
 
 std::unique_ptr<Module> BugDriver::extractLoop(Module *M) {
   std::vector<std::string> LoopExtractPasses;
   LoopExtractPasses.push_back("loop-extract-single");
 
   std::unique_ptr<Module> NewM = runPassesOn(M, LoopExtractPasses);
   if (!NewM) {
     outs() << "*** Loop extraction failed: ";
     EmitProgressBitcode(*M, "loopextraction", true);
-    outs() << "*** Sorry. :(  Please report a bug!\n";
+    outs() << "*** Please report a bug!\n";
     return nullptr;
   }
 
   // Check to see if we created any new functions.  If not, no loops were
   // extracted and we should return null.  Limit the number of loops we extract
   // to avoid taking forever.
   static unsigned NumExtracted = 32;
   if (M->size() == NewM->size() || --NumExtracted == 0) {

llvm/utils/check-each-file

 do
   rm -f $f
   gmake $f CC=llvm-native-gcc CXX=llvm-native-gxx
 done
 rm -f $program
 $linker
 if $checker
 then
-  echo "Sorry, I can't help you, $program is OK when compiled with llvm-native-gcc"
+  echo "I cannot help you, $program is OK when compiled with llvm-native-gcc"
   exit 1
 fi
 for f in $files
 do
   echo Trying to compile $f with native gcc and rebuild $program
   mv ${f} ${f}__OLD__
   gmake ${f} CC=gcc > /dev/null 2>&1
   $linker

polly/lib/External/isl/imath/tests/test.sh

 #!/bin/bash
 ## 
 ## Name:     test.sh
 ## Purpose:  Run test suites for IMath library.
 ##
 ## Copyright (C) 2002-2007 Michael J. Fromberger. All Rights Reserved.
 ##
 
 set -o pipefail
 
 if [ ! -f ../imtest ] ; then
-  echo "I can't find the imath test driver 'imtest', did you build it?"
-  echo "I can't proceed with the unit tests until you do so, sorry."
+  echo "The imath test driver 'imtest' was not found."
+  echo "It needs to be build before proceeding with the unit tests."
   exit 2
 fi
 
 echo "-- Running all available unit tests"
 if ../imtest *.tc | (grep -v 'OK'||true) ; then
     echo "ALL PASSED"
 else
     echo "FAILED"
     exit 1
 fi
 
 echo ""
 echo "-- Running test to compute 1024 decimal digits of pi"
 if [ ! -f ../pi ] ; then
-  echo "I can't find the pi computing program, did you build it?"
-  echo "I can't proceed with the pi test until you do so, sorry."
+  echo "The pi computing program was not found."
+  echo "It needs to be built before proceeding with the pi test."
   exit 1
 fi
 
 tempfile="/tmp/pi.1024.$$"
 
 ../pi 1024 | tr -d '\r\n' > ${tempfile}
 if cmp -s ${tempfile} ./pi1024.txt ; then
   echo "  PASSED 1024 digits"