[lldb] Mark expressions that couldn't be parsed or executed as failed expressions

[teemperor]

Summary

LLDB keeps statistics of how many expression evaluations are 'successful' and 'failed'
which are updated after each expression evaluation (assuming statistics are enabled).
From what I understand the idea is that this could be used to define how well LLDB's
expression evaluator is working.

Currently all expressions are considered successful unless the user passes an explicit
positive element counting to the expression command (with the -Z flag) and then passes
an expression that successfully evaluates to a type that doesn't support element counting.
Expressions that fail to parse, execute or any other outcome are considered successful
at the moment which means we nearly always have a 100% expression evaluation
success rate.

This patch makes that expressions that fail to parse or execute to count as failed
expressions.

We can't know whether the expression failed because of an user error
of because LLDB couldn't correctly parse/compile it, but I would argue that this is
still an improvement. Assuming that the percentage of valid user expressions stays
mostly constant over time (which seems like a reasonable assumption), then this
way we can still see if we are doing relatively better/worse from release to release.

[teemperor]

• Rebased

lldb/source/Commands/CommandObjectExpression.h

bool IOHandlerIsInputComplete(IOHandler &io_handler,
                                 StringList &lines) override;
 
   bool DoExecute(llvm::StringRef command, CommandReturnObject &result) override;
 
   /// Return the appropriate expression options used for evaluating the
   /// expression in the given target.
   EvaluateExpressionOptions GetEvalOptions(const Target &target);
 
+  /// Evaluates the given expression.
+  /// \param output_stream The stream to which the evaluation result will be
+  ///                      printed.
+  /// \param error_stream Contains error messages that should be displayed to
+  ///                     the user in case the evaluation fails.
+  /// \param result A CommandReturnObject which status will be set to the
+  ///               appropriate value depending on evaluation success and
+  ///               whether the expression produced any result.
+  /// \return Returns true iff the expression was successfully evaluated,
+  ///         executed and the result could be printed to the output stream.
   bool EvaluateExpression(llvm::StringRef expr, Stream &output_stream,
                           Stream &error_stream, CommandReturnObject &result);
 
   void GetMultilineExpression();
 
   OptionGroupOptions m_option_group;
   OptionGroupFormat m_format_options;
   OptionGroupValueObjectDisplay m_varobj_options;

lldb/source/Commands/CommandObjectExpression.cpp

if (result_valobj_sp->GetError().Success()) {
           error_stream.PutCString("error: unknown error\n");
         }
 
         result.SetStatus(eReturnStatusFailed);
       }
     }
   }
 
-  return true;
+  return (success != eExpressionSetupError &&
+          success != eExpressionParseError);
 }
 
 void CommandObjectExpression::IOHandlerInputComplete(IOHandler &io_handler,
                                                      std::string &line) {
   io_handler.SetIsDone(true);
   //    StreamSP output_stream =
   //    io_handler.GetDebugger().GetAsyncOutputStream();
   //    StreamSP error_stream = io_handler.GetDebugger().GetAsyncErrorStream();

lldb/test/API/commands/statistics/basic/TestStats.py

def test(self):
         # 'expression' should change the statistics.
         self.expect("statistics enable")
         self.expect("statistics enable", substrs=['already enabled'], error=True)
         self.expect("expr patatino", substrs=['27'])
         self.expect("statistics disable")
         self.expect("statistics dump", substrs=['expr evaluation successes : 1\n',
                                                 'expr evaluation failures : 0\n'])
 
+        self.expect("statistics enable")
+        # Doesn't parse.
+        self.expect("expr doesnt_exist", error=True,
+                    substrs=["undeclared identifier 'doesnt_exist'"])
+        # Doesn't successfully execute.
+        self.expect("expr int *i = nullptr; *i", error=True)
+        # Interpret an integer as an array with 3 elements is also a failure.
+        self.expect("expr -Z 3 -- 1", error=True,
+                    substrs=["expression cannot be used with --element-count"])
+        self.expect("statistics disable")
+        # We should have gotten 3 new failures and the previous success.
+        self.expect("statistics dump", substrs=['expr evaluation successes : 1\n',
+                                                'expr evaluation failures : 3\n'])
+
         # 'frame var' with disabled statistics shouldn't change stats.
         self.expect("frame var", substrs=['27'])
 
         self.expect("statistics enable")
         # 'frame var' with enabled statistics will change stats.
         self.expect("frame var", substrs=['27'])
         self.expect("statistics disable")
         self.expect("statistics dump", substrs=['frame var successes : 1\n',
                                                 'frame var failures : 0\n'])