[lldb][Expression] Emit hint to use --c++-ignore-context-qualifiers (llvm#177927)

Depends on:
* llvm#177921
* llvm#177926

(only last commit is relevant for this review)

This patch emits a workaround suggestion (in the form of a `note:`
diagnostic) when an expression fails due to trying to mutate state/call
functions with CV-qualifiers that are disallowed by C++ language rules
based on the context the expression is evaluated in. The note looks as
follows:
```
(lldb) expr next.method()
            ˄
            ╰─ error: 'this' argument to member function 'method' has type 'const Bar', but function is not marked const
note: Ran expression as 'C++14'.
note: note: 'method' declared here
note: Possibly trying to mutate object in a const context. Try running the expression with: expression --c++-ignore-context-qualifiers -- <your expression>
```

(cherry picked from commit 58912f3)

Author: Michael137

lldb/include/lldb/Expression/UserExpression.h

@@ -312,6 +312,16 @@ class UserExpression : public Expression {
                            lldb::ProcessSP &process_sp,
                            lldb::StackFrameSP &frame_sp);
 
+  /// Called by expression evaluator when a parse error occurs. Gives this
+  /// UserExpression object a chance to inspect and adjust the error diagnostics
+  /// contained in the specified \c diagnostic_manager.
+  ///
+  /// \param[in,out] diagnostic_manager DiagnosticManager manager holding the
+  /// parse error diagnostics. This function may mutate the diagnostics.
+  ///
+  virtual void
+  FixupParseErrorDiagnostics(DiagnosticManager &diagnostic_manager) const {}
+
   /// The address the process is stopped in.
   Address m_address;
   /// The text of the expression, as typed by the user.

lldb/source/Expression/UserExpression.cpp

@@ -330,6 +330,9 @@ UserExpression::Evaluate(ExecutionContext &exe_ctx,
     }
 
     if (!parse_success) {
+      if (user_expression_sp)
+        user_expression_sp->FixupParseErrorDiagnostics(diagnostic_manager);
+
       if (target->GetEnableNotifyAboutFixIts() && fixed_expression &&
           !fixed_expression->empty()) {
         std::string fixit =

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

@@ -27,6 +27,7 @@
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/ExpressionSourceCode.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
@@ -55,6 +56,7 @@
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 
@@ -946,6 +948,46 @@ lldb::ExpressionVariableSP ClangUserExpression::GetResultAfterDematerialization(
   return m_result_delegate.GetVariable();
 }
 
+void ClangUserExpression::FixupParseErrorDiagnostics(
+    DiagnosticManager &diagnostic_manager) const {
+  const bool is_fixable_cvr_error = llvm::any_of(
+      diagnostic_manager.Diagnostics(),
+      [](std::unique_ptr<Diagnostic> const &diag) {
+        switch (diag->GetCompilerID()) {
+        case clang::diag::err_member_function_call_bad_cvr:
+          return true;
+        case clang::diag::err_typecheck_assign_const:
+          // FIXME: can we split this particular error into a separate
+          // diagnostic ID so we don't need to scan the error message?
+          return diag->GetDetail().message.find(
+                     "within const member function") != std::string::npos;
+        default:
+          return false;
+        }
+      });
+
+  // Nothing to report.
+  if (!is_fixable_cvr_error)
+    return;
+
+  // If the user already tried ignoring function qualifiers but
+  // the expression still failed, we don't want to suggest the hint again.
+  if (m_options.GetCppIgnoreContextQualifiers()) {
+    // Hard to prove that we don't get here so don't emit a diagnostic n
+    // non-asserts builds. But we do want a signal in asserts builds.
+    assert(false &&
+           "CppIgnoreContextQualifiers didn't resolve compiler diagnostic.");
+    return;
+  }
+
+  diagnostic_manager.Printf(
+      lldb::eSeverityInfo,
+      "Possibly trying to mutate object in a const context. Try "
+      "running the expression with: expression --c++-ignore-context-qualifiers "
+      "-- %s",
+      !m_fixed_text.empty() ? m_fixed_text.c_str() : m_expr_text.c_str());
+}
+
 char ClangUserExpression::ClangUserExpressionHelper::ID;
 
 void ClangUserExpression::ClangUserExpressionHelper::ResetDeclMap(

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

@@ -188,6 +188,10 @@ class ClangUserExpression : public LLVMUserExpression {
 
   llvm::StringRef GetFilename() const { return m_filename; }
 
+protected:
+  void FixupParseErrorDiagnostics(
+      DiagnosticManager &diagnostic_manager) const override;
+
 private:
   /// Populate m_in_cplusplus_method and m_in_objectivec_method based on the
   /// environment.

lldb/test/API/lang/cpp/expression-context-qualifiers/const_method/TestExprInConstMethod.py

@@ -16,15 +16,16 @@ def test(self):
             "expression m_const_mem = 2.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member",
-                "with const-qualified type",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
+            matching=False,
         )
         self.expect(
             "expression m_mem = 2.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member within const member function"
+                "cannot assign to non-static data member within const member function",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
         self.expect_expr("m_mem", result_value="-2")
@@ -60,7 +61,8 @@ def test(self):
             "expression x = 7.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member within const member function"
+                "cannot assign to non-static data member within const member function",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
         self.expect_expr("x", result_value="2")
@@ -87,15 +89,16 @@ def test(self):
             "expression m_const_mem = 2.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member",
-                "with const-qualified type",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
+            matching=False,
         )
         self.expect(
             "expression m_mem = 2.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member within const member function"
+                "cannot assign to non-static data member within const member function",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
         self.expect_expr("m_mem", result_value="-2")
@@ -117,15 +120,16 @@ def test(self):
             "expression m_const_mem = 2.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member",
-                "with const-qualified type",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
+            matching=False,
         )
         self.expect(
             "expression m_mem = 2.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member within const member function"
+                "cannot assign to non-static data member within const member function",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
         self.expect_expr("m_mem", result_value="-1")

lldb/test/API/lang/cpp/expression-context-qualifiers/const_volatile_method/TestExprInConstVolatileMethod.py

@@ -17,7 +17,11 @@ def test(self):
         self.expect(
             "expression volatile_method()",
             error=True,
-            substrs=["has type 'const Foo'", "but function is not marked const"],
+            substrs=[
+                "has type 'const Foo'",
+                "but function is not marked const",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
+            ],
         )
 
         options = lldb.SBExpressionOptions()
@@ -41,7 +45,11 @@ def test(self):
         self.expect(
             "expression const_method()",
             error=True,
-            substrs=["has type 'volatile Foo'", "but function is not marked volatile"],
+            substrs=[
+                "has type 'volatile Foo'",
+                "but function is not marked volatile",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
+            ],
         )
         self.expect_expr("volatile_method()")
 
@@ -65,6 +73,7 @@ def test(self):
             substrs=[
                 "has type 'const volatile Foo'",
                 "but function is not marked const or volatile",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
         self.expect(
@@ -73,6 +82,7 @@ def test(self):
             substrs=[
                 "has type 'const volatile Foo'",
                 "but function is not marked const or volatile",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
 

lldb/test/API/lang/cpp/expression-context-qualifiers/fixit/TestExprInConstMethodWithFixit.py

@@ -17,10 +17,12 @@ def test(self):
             substrs=[
                 "member reference type 'const Bar' is not a pointer",
                 "but function is not marked const",
+                "Possibly trying to mutate object in a const context. Try running the expression with",
+                "expression --c++-ignore-context-qualifiers -- m_bar.method()",
             ],
         )
 
-        # Two fix-its
+        # Two fix-its...
         self.expect(
             "expression -- m_bar->method() + m_bar->method()",
             error=True,
@@ -32,11 +34,36 @@ def test(self):
             ],
         )
 
+        # ...only emit a single hint.
+        self.assertEqual(
+            self.res.GetError().count(
+                "Possibly trying to mutate object in a const context."
+            ),
+            1,
+        )
+
+        self.expect(
+            "expression -Q -- m_bar->method()",
+            error=True,
+            substrs=["Evaluated this expression after applying Fix-It(s):"],
+        )
+
         self.expect(
             "expression m_bar->method() + blah",
             error=True,
             substrs=[
                 "member reference type 'const Bar' is not a pointer",
                 "but function is not marked const",
+                "Possibly trying to mutate object in a const context. Try running the expression with",
+                "expression --c++-ignore-context-qualifiers -- m_bar.method() + blah",
+            ],
+        )
+
+        self.expect(
+            "expression -Q -- m_bar->method() + blah",
+            error=True,
+            substrs=[
+                "Possibly trying to mutate object in a const context. Try running the expression with",
             ],
+            matching=False,
         )

lldb/test/API/lang/cpp/expression-context-qualifiers/non_const_method/TestExprInNonConstMethod.py

@@ -32,7 +32,8 @@ def test(self):
             "expression x = 7.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member within const member function"
+                "cannot assign to non-static data member within const member function",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
 

lldb/test/API/lang/cpp/expression-context-qualifiers/template_const_method/TestExprInTemplateConstMethod.py

@@ -24,7 +24,8 @@ def test(self):
             "expression m_mem = 2.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member within const member function"
+                "cannot assign to non-static data member within const member function",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
         self.expect_expr("((Foo*)this)->bar()", result_type="double", result_value="5")
@@ -44,7 +45,8 @@ def test(self):
             "expression x = 7.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member within const member function"
+                "cannot assign to non-static data member within const member function",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
         self.expect_expr("x = -7.0; x", options=options, result_value="-7")
@@ -77,7 +79,8 @@ def test(self):
             "expression m_mem = 2.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member within const member function"
+                "cannot assign to non-static data member within const member function",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
         self.expect_expr("m_mem", result_value="-2")
@@ -105,7 +108,8 @@ def test(self):
             "expression m_mem = 2.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member within const member function"
+                "cannot assign to non-static data member within const member function",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
             ],
         )
         self.expect_expr("m_mem = -11.0; m_mem", options=options, result_value="-11")

lldb/test/API/lang/cpp/expression-context-qualifiers/template_non_const_method/TestExprInTemplateNonConstMethod.py

@@ -32,7 +32,9 @@ def test(self):
             "expression x = 7.0",
             error=True,
             substrs=[
-                "cannot assign to non-static data member within const member function"
+                "cannot assign to non-static data member within const member function",
+                "note: Possibly trying to mutate object in a const context. Try running the expression with",
+                "expression --c++-ignore-context-qualifiers -- x = 7.0",
             ],
         )