Streamline expression parser error messages

[aprantl]

Summary

Currently the expression parser prints a mostly useless generic error before printing the compiler error:

(lldb) p 1+x)
error: expression failed to parse:
error: <user expression 18>:1:3: use of undeclared identifier 'x'
1+x)
  ^

This is distracting and as far as I can tell only exists to work around the fact that the first "error: " is unconditionally injected by CommandReturnObject. The solution is not very elegant, but the result looks much better.

(Partially addresses rdar://110492710)

[aprantl]

pinging after the weekend.

[JDevlieghere]

Ship it

[kastiglione]

lldb/source/Interpreter/CommandReturnObject.cpp

104

nice

lldb/source/Expression/UserExpression.cpp

if (!fixed_expression->empty() && options.GetAutoApplyFixIts()) {
         }
       }
     }
 
     if (!parse_success) {
       std::string msg;
       {
         llvm::raw_string_ostream os(msg);
-        os << "expression failed to parse:\n";
         if (!diagnostic_manager.Diagnostics().empty())
           os << diagnostic_manager.GetString();
         else
-          os << "unknown error";
+          os << "expression failed to parse (no further compiler diagnostics)";
         if (target->GetEnableNotifyAboutFixIts() && fixed_expression &&
             !fixed_expression->empty())
           os << "\nfixed expression suggested:\n  " << *fixed_expression;
       }
       error.SetExpressionError(execution_results, msg.c_str());
     }
   }
 

lldb/source/Interpreter/CommandReturnObject.cpp

if (in_string.empty())
     return;
   warning(GetErrorStream()) << in_string.rtrim() << '\n';
 }
 
 void CommandReturnObject::AppendError(llvm::StringRef in_string) {
   SetStatus(eReturnStatusFailed);
   if (in_string.empty())
     return;
-  error(GetErrorStream()) << in_string.rtrim() << '\n';
+  // Workaround to deal with already fully formatted compiler diagnostics.
+  llvm::StringRef msg(in_string.rtrim());
+  msg.consume_front("error: ");
+  error(GetErrorStream()) << msg << '\n';
 }
 
 void CommandReturnObject::SetError(const Status &error,
                                    const char *fallback_error_cstr) {
   if (error.Fail())
     AppendError(error.AsCString(fallback_error_cstr));
 }
 

lldb/test/API/commands/expression/diagnostics/TestExprDiagnostics.py

""",
         )
 
         # Redefine something that we defined in a user-expression. We should use the previous expression file name
         # for the original decl.
         value = frame.EvaluateExpression("struct Redef { double x; };", top_level_opts)
         value = frame.EvaluateExpression("struct Redef { float y; };", top_level_opts)
         self.assertFalse(value.GetError().Success())
         self.assertIn(
-            """
-error: <user expression 9>:1:8: redefinition of 'Redef'
+            """error: <user expression 9>:1:8: redefinition of 'Redef'
     1 | struct Redef { float y; };
       |        ^
 <user expression 8>:1:8: previous definition is here
     1 | struct Redef { double x; };
       |        ^
 """,
             value.GetError().GetCString(),
         )

lldb/test/API/commands/expression/fixits/TestFixIts.py

def test_with_multiple_retries(self):
           return s1.f();
         }
         """
 
         # Disable retries which will fail.
         multiple_runs_options.SetRetriesWithFixIts(0)
         value = frame.EvaluateExpression(two_runs_expr, multiple_runs_options)
         errmsg = value.GetError().GetCString()
-        self.assertIn("expression failed to parse", errmsg)
         self.assertIn("using declaration resolved to type without 'typename'", errmsg)
         self.assertIn("fixed expression suggested:", errmsg)
         self.assertIn("using typename T::TypeDef", errmsg)
         # The second Fix-It shouldn't be suggested here as Clang should have
         # aborted the parsing process.
         self.assertNotIn("i->m", errmsg)
 
         # Retry once, but the expression needs two retries.
         multiple_runs_options.SetRetriesWithFixIts(1)
         value = frame.EvaluateExpression(two_runs_expr, multiple_runs_options)
         errmsg = value.GetError().GetCString()
-        self.assertIn("expression failed to parse", errmsg)
         self.assertIn("fixed expression suggested:", errmsg)
         # Both our fixed expressions should be in the suggested expression.
         self.assertIn("using typename T::TypeDef", errmsg)
         self.assertIn("i->m", errmsg)
 
         # Retry twice, which will get the expression working.
         multiple_runs_options.SetRetriesWithFixIts(2)
         value = frame.EvaluateExpression(two_runs_expr, multiple_runs_options)
         # This error signals success for top level expressions.
         self.assertEquals(value.GetError().GetCString(), "unknown error")
 
         # Test that the code above compiles to the right thing.
         self.expect_expr("test_X(1)", result_type="int", result_value="123")