[lldb][NFC] Remove unused ExpressionParser::Parse

[teemperor]

Summary

This function is only used internally by ClangExpressionParser. By putting it in the ExpressionParser class all languages
that implement ExpressionParser::Parse have to share the same signature (which forces us in downstream to add
swift-specific arguments to ExpressionParser::Parse which then propagate to ClangExpressionParser and so on).

[teemperor]

• Uploaded full diff.

lldb/include/lldb/Expression/ExpressionParser.h

public:
   ///     expression).
   ///
   /// \return
   ///     True if we added any completion results to the output;
   ///     false otherwise.
   virtual bool Complete(CompletionRequest &request, unsigned line, unsigned pos,
                         unsigned typed_pos) = 0;
 
-  /// Parse a single expression and convert it to IR using Clang.  Don't wrap
-  /// the expression in anything at all.
-  ///
-  /// \param[in] diagnostic_manager
-  ///     The diagnostic manager in which to store the errors and warnings.
-  ///
-  /// \return
-  ///     The number of errors encountered during parsing.  0 means
-  ///     success.
-  virtual unsigned Parse(DiagnosticManager &diagnostic_manager) = 0;
-
   /// Try to use the FixIts in the diagnostic_manager to rewrite the
   /// expression.  If successful, the rewritten expression is stored in the
   /// diagnostic_manager, get it out with GetFixedExpression.
   ///
   /// \param[in] diagnostic_manager
   ///     The diagnostic manager containing fixit's to apply.
   ///
   /// \return

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

public:
   /// the expression in anything at all.
   ///
   /// \param[in] diagnostic_manager
   ///     The diagnostic manager to report errors to.
   ///
   /// \return
   ///     The number of errors encountered during parsing.  0 means
   ///     success.
-  unsigned Parse(DiagnosticManager &diagnostic_manager) override;
+  unsigned Parse(DiagnosticManager &diagnostic_manager);
 
   bool RewriteExpression(DiagnosticManager &diagnostic_manager) override;
 
   /// Ready an already-parsed expression for execution, possibly evaluating it
   /// statically.
   ///
   /// \param[out] func_addr
   ///     The address to which the function has been written.

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

ClangFunctionCaller::CompileFunction(lldb::ThreadSP thread_to_use_sp,
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
   LLDB_LOGF(log, "Expression: \n\n%s\n\n", m_wrapper_function_text.c_str());
 
   // Okay, now compile this expression
 
   lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
   if (jit_process_sp) {
     const bool generate_debug_info = true;
-    m_parser.reset(new ClangExpressionParser(jit_process_sp.get(), *this,
-                                             generate_debug_info));
-
-    num_errors = m_parser->Parse(diagnostic_manager);
+    auto *clang_parser = new ClangExpressionParser(jit_process_sp.get(), *this,
+                                                   generate_debug_info);
+    num_errors = clang_parser->Parse(diagnostic_manager);
+    m_parser.reset(clang_parser);
   } else {
     diagnostic_manager.PutString(eDiagnosticSeverityError,
                                  "no process - unable to inject function");
     num_errors = 1;
   }
 
   m_compiled = (num_errors == 0);