Replaced more boilerplate code with CompletionRequest (NFC)

[teemperor]

Summary

As suggested in D48796, this patch replaces even more internal calls that were using the old
completion API style with a single CompletionRequest. In some cases we also pass an option
vector/index, but as we don't always have this information, it currently is not part of the
CompletionRequest class.

The constructor of the CompletionRequest is now also more sensible. You only pass the
user input, cursor position and your list of matches to the request and the rest will be
inferred (using the same code we used before to calculate this). You also have to pass these
match window parameters to it, even though they are unused right now.

The patch shouldn't change any behavior.

[teemperor]

ping

[jingham]

Oops, sorry for the delay. This is so much easier to read. Thanks for cleaning this up!

lldb/trunk/include/lldb/Core/FormatEntity.h

 //===-- FormatEntity.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_FormatEntity_h_
 #define liblldb_FormatEntity_h_
 
+#include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/FileSpec.h" // for FileSpec
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h" // for Format::eFormatDefault, Format
 #include "lldb/lldb-types.h"        // for addr_t
 #include <algorithm>                // for min
 #include <stddef.h>                 // for size_t
 #include <stdint.h>                 // for uint32_t, uint64_t
 
static bool FormatCString(const char *format, Stream &s,
                             bool function_changed, bool initial_function);
 
   static Status Parse(const llvm::StringRef &format, Entry &entry);
 
   static Status ExtractVariableInfo(llvm::StringRef &format_str,
                                     llvm::StringRef &variable_name,
                                     llvm::StringRef &variable_format);
 
-  static size_t AutoComplete(llvm::StringRef s, int match_start_point,
-                             int max_return_elements, bool &word_complete,
-                             StringList &matches);
+  static size_t AutoComplete(lldb_private::CompletionRequest &request);
 
   //----------------------------------------------------------------------
   // Format the current elements into the stream \a s.
   //
   // The root element will be stripped off and the format str passed in will be
   // either an empty string (print a description of this object), or contain a
   // `.`-separated series like a domain name that identifies further
   //  sub-elements to display.

lldb/trunk/include/lldb/Interpreter/CommandCompletions.h

 // C Includes
 // C++ Includes
 #include <set>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/SearchFilter.h"
+#include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/Twine.h"
 
 namespace lldb_private {
 class TildeExpressionResolver;
 class CommandCompletions {
 public:
   //----------------------------------------------------------------------
   // This is the command completion callback that is used to complete the
   // argument of the option it is bound to (in the OptionDefinition table
   // below).  Return the total number of matches.
   //----------------------------------------------------------------------
-  typedef int (*CompletionCallback)(
-      CommandInterpreter &interpreter,
-      llvm::StringRef completion_str, // This is the argument we are completing
-      int match_start_point,   // This is the point in the list of matches that
-                               // you should start returning elements
-      int max_return_elements, // This is the number of matches requested.
-      lldb_private::SearchFilter
-          *searcher, // A search filter to limit the search...
-      bool &word_complete,
-      lldb_private::StringList &matches); // The array of matches we return.
+  typedef int (*CompletionCallback)(CommandInterpreter &interpreter,
+                                    CompletionRequest &request,
+                                    // A search filter to limit the search...
+                                    lldb_private::SearchFilter *searcher);
   typedef enum {
     eNoCompletion = 0u,
     eSourceFileCompletion = (1u << 0),
     eDiskFileCompletion = (1u << 1),
     eDiskDirectoryCompletion = (1u << 2),
     eSymbolCompletion = (1u << 3),
     eModuleCompletion = (1u << 4),
     eSettingsNameCompletion = (1u << 5),
     ePlatformPluginCompletion = (1u << 6),
     eArchitectureCompletion = (1u << 7),
     eVariablePathCompletion = (1u << 8),
     // This item serves two purposes.  It is the last element in the enum, so
     // you can add custom enums starting from here in your Option class. Also
     // if you & in this bit the base code will not process the option.
     eCustomCompletion = (1u << 9)
   } CommonCompletionTypes;
 
   struct CommonCompletionElement {
     uint32_t type;
     CompletionCallback callback;
   };
 
   static bool InvokeCommonCompletionCallbacks(
       CommandInterpreter &interpreter, uint32_t completion_mask,
-      llvm::StringRef completion_str, int match_start_point,
-      int max_return_elements, SearchFilter *searcher, bool &word_complete,
-      StringList &matches);
+      lldb_private::CompletionRequest &request, SearchFilter *searcher);
 
   //----------------------------------------------------------------------
   // These are the generic completer functions:
   //----------------------------------------------------------------------
   static int DiskFiles(CommandInterpreter &interpreter,
-                       llvm::StringRef partial_file_name, int match_start_point,
-                       int max_return_elements, SearchFilter *searcher,
-                       bool &word_complete, StringList &matches);
+                       CompletionRequest &request, SearchFilter *searcher);
 
   static int DiskFiles(const llvm::Twine &partial_file_name,
                        StringList &matches, TildeExpressionResolver &Resolver);
 
   static int DiskDirectories(CommandInterpreter &interpreter,
-                             llvm::StringRef partial_file_name,
-                             int match_start_point, int max_return_elements,
-                             SearchFilter *searcher, bool &word_complete,
-                             StringList &matches);
+                             CompletionRequest &request,
+                             SearchFilter *searcher);
 
   static int DiskDirectories(const llvm::Twine &partial_file_name,
                              StringList &matches,
                              TildeExpressionResolver &Resolver);
 
   static int SourceFiles(CommandInterpreter &interpreter,
-                         llvm::StringRef partial_file_name,
-                         int match_start_point, int max_return_elements,
-                         SearchFilter *searcher, bool &word_complete,
-                         StringList &matches);
+                         CompletionRequest &request, SearchFilter *searcher);
 
   static int Modules(CommandInterpreter &interpreter,
-                     llvm::StringRef partial_file_name, int match_start_point,
-                     int max_return_elements, SearchFilter *searcher,
-                     bool &word_complete, lldb_private::StringList &matches);
+                     CompletionRequest &request, SearchFilter *searcher);
 
   static int Symbols(CommandInterpreter &interpreter,
-                     llvm::StringRef partial_file_name, int match_start_point,
-                     int max_return_elements, SearchFilter *searcher,
-                     bool &word_complete, lldb_private::StringList &matches);
+                     CompletionRequest &request, SearchFilter *searcher);
 
   static int SettingsNames(CommandInterpreter &interpreter,
-                           llvm::StringRef partial_file_name,
-                           int match_start_point, int max_return_elements,
-                           SearchFilter *searcher, bool &word_complete,
-                           lldb_private::StringList &matches);
+                           CompletionRequest &request, SearchFilter *searcher);
 
   static int PlatformPluginNames(CommandInterpreter &interpreter,
-                                 llvm::StringRef partial_file_name,
-                                 int match_start_point, int max_return_elements,
-                                 SearchFilter *searcher, bool &word_complete,
-                                 lldb_private::StringList &matches);
+                                 CompletionRequest &request,
+                                 SearchFilter *searcher);
 
   static int ArchitectureNames(CommandInterpreter &interpreter,
-                               llvm::StringRef partial_file_name,
-                               int match_start_point, int max_return_elements,
-                               SearchFilter *searcher, bool &word_complete,
-                               lldb_private::StringList &matches);
+                               CompletionRequest &request,
+                               SearchFilter *searcher);
 
   static int VariablePath(CommandInterpreter &interpreter,
-                          llvm::StringRef partial_file_name,
-                          int match_start_point, int max_return_elements,
-                          SearchFilter *searcher, bool &word_complete,
-                          lldb_private::StringList &matches);
+                          CompletionRequest &request, SearchFilter *searcher);
 
   //----------------------------------------------------------------------
   // The Completer class is a convenient base class for building searchers that
   // go along with the SearchFilter passed to the standard Completer functions.
   //----------------------------------------------------------------------
   class Completer : public Searcher {
   public:
-    Completer(CommandInterpreter &interpreter, llvm::StringRef completion_str,
-              int match_start_point, int max_return_elements,
-              StringList &matches);
+    Completer(CommandInterpreter &interpreter, CompletionRequest &request);
 
     ~Completer() override;
 
     CallbackReturn SearchCallback(SearchFilter &filter, SymbolContext &context,
                                   Address *addr, bool complete) override = 0;
 
     Depth GetDepth() override = 0;
 
     virtual size_t DoCompletion(SearchFilter *filter) = 0;
 
   protected:
     CommandInterpreter &m_interpreter;
-    std::string m_completion_str;
-    int m_match_start_point;
-    int m_max_return_elements;
-    StringList &m_matches;
+    CompletionRequest &m_request;
 
   private:
     DISALLOW_COPY_AND_ASSIGN(Completer);
   };
 
   //----------------------------------------------------------------------
   // SourceFileCompleter implements the source file completer
   //----------------------------------------------------------------------
   class SourceFileCompleter : public Completer {
   public:
     SourceFileCompleter(CommandInterpreter &interpreter,
-                        bool include_support_files,
-                        llvm::StringRef completion_str, int match_start_point,
-                        int max_return_elements, StringList &matches);
+                        bool include_support_files, CompletionRequest &request);
 
     Searcher::Depth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
                                             Address *addr,
                                             bool complete) override;
 
public:
   };
 
   //----------------------------------------------------------------------
   // ModuleCompleter implements the module completer
   //----------------------------------------------------------------------
   class ModuleCompleter : public Completer {
   public:
     ModuleCompleter(CommandInterpreter &interpreter,
-                    llvm::StringRef completion_str, int match_start_point,
-                    int max_return_elements, StringList &matches);
+                    CompletionRequest &request);
 
     Searcher::Depth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
                                             Address *addr,
                                             bool complete) override;
 
     size_t DoCompletion(SearchFilter *filter) override;
 
   private:
     const char *m_file_name;
     const char *m_dir_name;
 
     DISALLOW_COPY_AND_ASSIGN(ModuleCompleter);
   };
 
   //----------------------------------------------------------------------
   // SymbolCompleter implements the symbol completer
   //----------------------------------------------------------------------
   class SymbolCompleter : public Completer {
   public:
     SymbolCompleter(CommandInterpreter &interpreter,
-                    llvm::StringRef completion_str, int match_start_point,
-                    int max_return_elements, StringList &matches);
+                    CompletionRequest &request);
 
     Searcher::Depth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
                                             Address *addr,
                                             bool complete) override;
 

lldb/trunk/include/lldb/Interpreter/OptionValue.h

 #ifndef liblldb_OptionValue_h_
 #define liblldb_OptionValue_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/FormatEntity.h"
+#include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-private-interfaces.h"
 
 namespace lldb_private {
 
public:
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign);
 
   virtual bool Clear() = 0;
 
   virtual lldb::OptionValueSP DeepCopy() const = 0;
 
   virtual size_t AutoComplete(CommandInterpreter &interpreter,
-                              llvm::StringRef s, int match_start_point,
-                              int max_return_elements, bool &word_complete,
-                              StringList &matches);
+                              CompletionRequest &request);
 
   //-----------------------------------------------------------------
   // Subclasses can override these functions
   //-----------------------------------------------------------------
   virtual lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
                                           llvm::StringRef name,
                                           bool will_modify,
                                           Status &error) const {

lldb/trunk/include/lldb/Interpreter/OptionValueArch.h

public:
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;
 
-  size_t AutoComplete(CommandInterpreter &interpreter, llvm::StringRef s,
-                      int match_start_point, int max_return_elements,
-                      bool &word_complete, StringList &matches) override;
+  size_t AutoComplete(CommandInterpreter &interpreter,
+                      lldb_private::CompletionRequest &request) override;
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 
   ArchSpec &GetCurrentValue() { return m_current_value; }
 
   const ArchSpec &GetCurrentValue() const { return m_current_value; }

lldb/trunk/include/lldb/Interpreter/OptionValueBoolean.h

SetValueFromString(const char *,
                      VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
-  size_t AutoComplete(CommandInterpreter &interpreter, llvm::StringRef s,
-                      int match_start_point, int max_return_elements,
-                      bool &word_complete, StringList &matches) override;
+  size_t AutoComplete(CommandInterpreter &interpreter,
+                      CompletionRequest &request) override;
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 
   //------------------------------------------------------------------
   /// Convert to bool operator.
   ///

lldb/trunk/include/lldb/Interpreter/OptionValueEnumeration.h

public:
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;
 
-  size_t AutoComplete(CommandInterpreter &interpreter, llvm::StringRef s,
-                      int match_start_point, int max_return_elements,
-                      bool &word_complete, StringList &matches) override;
+  size_t AutoComplete(CommandInterpreter &interpreter,
+                      CompletionRequest &request) override;
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 
   enum_type operator=(enum_type value) {
     m_current_value = value;
     return m_current_value;

lldb/trunk/include/lldb/Interpreter/OptionValueFileSpec.h

bool Clear() override {
     m_value_was_set = false;
     m_data_sp.reset();
     m_data_mod_time = llvm::sys::TimePoint<>();
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;
 
-  size_t AutoComplete(CommandInterpreter &interpreter, llvm::StringRef s,
-                      int match_start_point, int max_return_elements,
-                      bool &word_complete, StringList &matches) override;
+  size_t AutoComplete(CommandInterpreter &interpreter,
+                      CompletionRequest &request) override;
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 
   FileSpec &GetCurrentValue() { return m_current_value; }
 
   const FileSpec &GetCurrentValue() const { return m_current_value; }

lldb/trunk/include/lldb/Interpreter/OptionValueFormatEntity.h

public:
   Status
   SetValueFromString(const char *,
                      VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override;
 
   lldb::OptionValueSP DeepCopy() const override;
 
-  size_t AutoComplete(CommandInterpreter &interpreter, llvm::StringRef s,
-                      int match_start_point, int max_return_elements,
-                      bool &word_complete, StringList &matches) override;
+  size_t AutoComplete(CommandInterpreter &interpreter,
+                      CompletionRequest &request) override;
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 
   FormatEntity::Entry &GetCurrentValue() { return m_current_entry; }
 
   const FormatEntity::Entry &GetCurrentValue() const { return m_current_entry; }

lldb/trunk/include/lldb/Interpreter/OptionValueUUID.h

public:
   //---------------------------------------------------------------------
 
   UUID &GetCurrentValue() { return m_uuid; }
 
   const UUID &GetCurrentValue() const { return m_uuid; }
 
   void SetCurrentValue(const UUID &value) { m_uuid = value; }
 
-  size_t AutoComplete(CommandInterpreter &interpreter, llvm::StringRef s,
-                      int match_start_point, int max_return_elements,
-                      bool &word_complete, StringList &matches) override;
+  size_t AutoComplete(CommandInterpreter &interpreter,
+                      CompletionRequest &request) override;
 
 protected:
   UUID m_uuid;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionValueUUID_h_

lldb/trunk/include/lldb/Interpreter/Options.h

public:
   //------------------------------------------------------------------
   virtual Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                                 ExecutionContext *execution_context) = 0;
 
   //------------------------------------------------------------------
   /// Handles the generic bits of figuring out whether we are in an option,
   /// and if so completing it.
   ///
-  /// @param[in] input
-  ///    The command line parsed into words
-  ///
-  /// @param[in] cursor_index
-  ///     The index in \ainput of the word in which the cursor lies.
-  ///
-  /// @param[in] char_pos
-  ///     The character position of the cursor in its argument word.
-  ///
-  /// @param[in] match_start_point
-  /// @param[in] match_return_elements
-  ///     See CommandObject::HandleCompletions for a description of
-  ///     how these work.
+  /// @param[in/out] request
+  ///    The completion request that we need to act upon.
   ///
   /// @param[in] interpreter
   ///     The interpreter that's doing the completing.
   ///
-  /// @param[out] word_complete
-  ///     \btrue if this is a complete option value (a space will be
-  ///     inserted after the completion.) \b false otherwise.
-  ///
-  /// @param[out] matches
-  ///     The array of matches returned.
-  ///
   /// FIXME: This is the wrong return value, since we also need to
   /// make a distinction between total number of matches, and the window the
   /// user wants returned.
   ///
   /// @return
   ///     \btrue if we were in an option, \bfalse otherwise.
   //------------------------------------------------------------------
-  bool HandleOptionCompletion(Args &input, OptionElementVector &option_map,
-                              int cursor_index, int char_pos,
-                              int match_start_point, int max_return_elements,
-                              CommandInterpreter &interpreter,
-                              bool &word_complete,
-                              lldb_private::StringList &matches);
+  bool HandleOptionCompletion(lldb_private::CompletionRequest &request,
+                              OptionElementVector &option_map,
+                              CommandInterpreter &interpreter);
 
   //------------------------------------------------------------------
   /// Handles the generic bits of figuring out whether we are in an option,
   /// and if so completing it.
   ///
-  /// @param[in] interpreter
-  ///    The command interpreter doing the completion.
-  ///
-  /// @param[in] input
-  ///    The command line parsed into words
-  ///
-  /// @param[in] cursor_index
-  ///     The index in \ainput of the word in which the cursor lies.
-  ///
-  /// @param[in] char_pos
-  ///     The character position of the cursor in its argument word.
-  ///
-  /// @param[in] opt_element_vector
-  ///     The results of the options parse of \a input.
-  ///
-  /// @param[in] opt_element_index
-  ///     The position in \a opt_element_vector of the word in \a
-  ///     input containing the cursor.
-  ///
-  /// @param[in] match_start_point
-  /// @param[in] match_return_elements
-  ///     See CommandObject::HandleCompletions for a description of
-  ///     how these work.
+  /// @param[in/out] request
+  ///    The completion request that we need to act upon.
   ///
   /// @param[in] interpreter
-  ///     The command interpreter in which we're doing completion.
-  ///
-  /// @param[out] word_complete
-  ///     \btrue if this is a complete option value (a space will
-  ///     be inserted after the completion.) \bfalse otherwise.
-  ///
-  /// @param[out] matches
-  ///     The array of matches returned.
+  ///    The command interpreter doing the completion.
   ///
   /// FIXME: This is the wrong return value, since we also need to
   /// make a distinction between total number of matches, and the window the
   /// user wants returned.
   ///
   /// @return
   ///     \btrue if we were in an option, \bfalse otherwise.
   //------------------------------------------------------------------
   virtual bool
-  HandleOptionArgumentCompletion(Args &input, int cursor_index, int char_pos,
+  HandleOptionArgumentCompletion(lldb_private::CompletionRequest &request,
                                  OptionElementVector &opt_element_vector,
-                                 int opt_element_index, int match_start_point,
-                                 int max_return_elements,
-                                 CommandInterpreter &interpreter,
-                                 bool &word_complete, StringList &matches);
+                                 int opt_element_index,
+                                 CommandInterpreter &interpreter);
 
 protected:
   // This is a set of options expressed as indexes into the options table for
   // this Option.
   typedef std::set<int> OptionSet;
   typedef std::vector<OptionSet> OptionSetVector;
 
   std::vector<Option> m_getopt_table;

lldb/trunk/include/lldb/Symbol/Variable.h

typedef size_t (*GetVariableCallback)(void *baton, const char *name,
                                         VariableList &var_list);
 
   static Status GetValuesForVariableExpressionPath(
       llvm::StringRef variable_expr_path, ExecutionContextScope *scope,
       GetVariableCallback callback, void *baton, VariableList &variable_list,
       ValueObjectList &valobj_list);
 
   static size_t AutoComplete(const ExecutionContext &exe_ctx,
-                             llvm::StringRef name, StringList &matches,
-                             bool &word_complete);
+                             CompletionRequest &request);
 
   CompilerDeclContext GetDeclContext();
 
   CompilerDecl GetDecl();
 
 protected:
   ConstString m_name; // The basename of the variable (no namespaces)
   Mangled m_mangled;  // The mangled name of the variable

lldb/trunk/include/lldb/Utility/ArchSpec.h

 //===-- ArchSpec.h ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_ARCHSPEC_H
 #define LLDB_UTILITY_ARCHSPEC_H
 
+#include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "llvm/ADT/StringRef.h" // for StringRef
 #include "llvm/ADT/Triple.h"
 #include <cstddef> // for size_t
 #include <cstdint> // for uint32_t
public:
 
   //---------------------------------------------------------------------------
   /// Returns true if the OS, vendor and environment fields of the triple are
   /// unset. The triple is expected to be normalized
   /// (llvm::Triple::normalize).
   //---------------------------------------------------------------------------
   static bool ContainsOnlyArch(const llvm::Triple &normalized_triple);
 
-  static size_t AutoComplete(llvm::StringRef name, StringList &matches);
+  static void ListSupportedArchNames(StringList &list);
+  static size_t AutoComplete(CompletionRequest &request);
 
   //------------------------------------------------------------------
   /// Returns a static string representing the current architecture.
   ///
   /// @return A static string corresponding to the current
   ///         architecture.
   //------------------------------------------------------------------
   const char *GetArchitectureName() const;

lldb/trunk/include/lldb/Utility/CompletionRequest.h

 ///
 /// Contains all information necessary to complete an incomplete command
 /// for the user. Will be filled with the generated completions by the different
 /// completions functions.
 ///
 //----------------------------------------------------------------------
 class CompletionRequest {
 public:
-  //----------------------------------------------------------------------
+  //----------------------------------------------------------
   /// Constructs a completion request.
   ///
-  /// See the respective members of this class for documentation for the
-  /// parameters.
-  // TODO: Infer the parsed_line and the cursor positions from the other
-  // arguments.
-  //----------------------------------------------------------------------
-  CompletionRequest(llvm::StringRef command, unsigned raw_cursor_pos,
-                    Args &parsed_line, int cursor_index,
-                    int cursor_char_position, int match_start_point,
-                    int max_return_elements, bool word_complete,
+  /// @param [in] command_line
+  ///     The command line the user has typed at this point.
+  ///
+  /// @param [in] raw_cursor_pos
+  ///     The position of the cursor in the command line string. Index 0 means
+  ///     the cursor is at the start of the line. The completion starts from
+  ///     this cursor position.
+  ///
+  /// @param [in] match_start_point
+  /// @param [in] max_return_elements
+  ///     If there is a match that is expensive to compute, these are here to
+  ///     allow you to compute the completions in  batches.  Start the
+  ///     completion from match_start_point, and return match_return_elements
+  ///     elements.
+  ///
+  /// @param [out] matches
+  ///     A list of matches that will be filled by the different completion
+  ///     handlers.
+  //----------------------------------------------------------
+  CompletionRequest(llvm::StringRef command_line, unsigned raw_cursor_pos,
+                    int match_start_point, int max_return_elements,
                     StringList &matches);
 
   llvm::StringRef GetRawLine() const { return m_command; }
 
   unsigned GetRawCursorPos() const { return m_raw_cursor_pos; }
 
+  const Args &GetParsedLine() const { return m_parsed_line; }
+
   Args &GetParsedLine() { return m_parsed_line; }
 
+  const Args &GetPartialParsedLine() const { return m_partial_parsed_line; }
+
   void SetCursorIndex(int i) { m_cursor_index = i; }
   int GetCursorIndex() const { return m_cursor_index; }
 
   void SetCursorCharPosition(int pos) { m_cursor_char_position = pos; }
   int GetCursorCharPosition() const { return m_cursor_char_position; }
 
   int GetMatchStartPoint() const { return m_match_start_point; }
 
   int GetMaxReturnElements() const { return m_max_return_elements; }
 
   bool GetWordComplete() { return m_word_complete; }
 
   void SetWordComplete(bool v) { m_word_complete = v; }
 
   /// The array of matches returned.
   StringList &GetMatches() { return *m_matches; }
 
+  llvm::StringRef GetCursorArgument() const {
+    return GetParsedLine().GetArgumentAtIndex(GetCursorIndex());
+  }
+
+  llvm::StringRef GetCursorArgumentPrefix() const {
+    return GetCursorArgument().substr(0, GetCursorCharPosition());
+  }
+
 private:
   /// The raw command line we are supposed to complete.
   llvm::StringRef m_command;
   /// The cursor position in m_command.
   unsigned m_raw_cursor_pos;
   /// The command line parsed as arguments.
   Args m_parsed_line;
+  /// The command line until the cursor position parsed as arguments.
+  Args m_partial_parsed_line;
   /// The index of the argument in which the completion cursor is.
   int m_cursor_index;
   /// The cursor position in the argument indexed by m_cursor_index.
   int m_cursor_char_position;
   /// If there is a match that is expensive
   /// to compute, these are here to allow you to compute the completions in
   /// batches.  Start the completion from \amatch_start_point, and return
   /// \amatch_return_elements elements.
   // FIXME: These two values are not implemented.
   int m_match_start_point;
   int m_max_return_elements;
   /// \btrue if this is a complete option value (a space will be inserted
   /// after the completion.)  \bfalse otherwise.
-  bool m_word_complete;
+  bool m_word_complete = false;
   // We don't own the list.
   StringList *m_matches;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_COMPLETIONREQUEST_H

lldb/trunk/source/Commands/CommandCompletions.cpp

CommandCompletions::g_common_completions[] = {
         {ePlatformPluginCompletion, CommandCompletions::PlatformPluginNames},
         {eArchitectureCompletion, CommandCompletions::ArchitectureNames},
         {eVariablePathCompletion, CommandCompletions::VariablePath},
         {eNoCompletion, nullptr} // This one has to be last in the list.
 };
 
 bool CommandCompletions::InvokeCommonCompletionCallbacks(
     CommandInterpreter &interpreter, uint32_t completion_mask,
-    llvm::StringRef completion_str, int match_start_point,
-    int max_return_elements, SearchFilter *searcher, bool &word_complete,
-    StringList &matches) {
+    CompletionRequest &request, SearchFilter *searcher) {
   bool handled = false;
 
   if (completion_mask & eCustomCompletion)
     return false;
 
   for (int i = 0;; i++) {
     if (g_common_completions[i].type == eNoCompletion)
       break;
     else if ((g_common_completions[i].type & completion_mask) ==
                  g_common_completions[i].type &&
              g_common_completions[i].callback != nullptr) {
       handled = true;
-      g_common_completions[i].callback(interpreter, completion_str,
-                                       match_start_point, max_return_elements,
-                                       searcher, word_complete, matches);
+      g_common_completions[i].callback(interpreter, request, searcher);
     }
   }
   return handled;
 }
 
 int CommandCompletions::SourceFiles(CommandInterpreter &interpreter,
-                                    llvm::StringRef partial_file_name,
-                                    int match_start_point,
-                                    int max_return_elements,
-                                    SearchFilter *searcher, bool &word_complete,
-                                    StringList &matches) {
-  word_complete = true;
+                                    CompletionRequest &request,
+                                    SearchFilter *searcher) {
+  request.SetWordComplete(true);
   // Find some way to switch "include support files..."
-  SourceFileCompleter completer(interpreter, false, partial_file_name,
-                                match_start_point, max_return_elements,
-                                matches);
+  SourceFileCompleter completer(interpreter, false, request);
 
   if (searcher == nullptr) {
     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
     completer.DoCompletion(&null_searcher);
   } else {
     completer.DoCompletion(searcher);
   }
-  return matches.GetSize();
+  return request.GetMatches().GetSize();
 }
 
 static int DiskFilesOrDirectories(const llvm::Twine &partial_name,
-                                  bool only_directories, bool &saw_directory,
-                                  StringList &matches,
+                                  bool only_directories, StringList &matches,
                                   TildeExpressionResolver &Resolver) {
   matches.Clear();
 
   llvm::SmallString<256> CompletionBuffer;
   llvm::SmallString<256> Storage;
   partial_name.toVector(CompletionBuffer);
 
   if (CompletionBuffer.size() >= PATH_MAX)
if (CompletionBuffer.startswith("~")) {
 
     llvm::SmallString<PATH_MAX> Resolved;
     if (!Resolver.ResolveExact(Username, Resolved)) {
       // We couldn't resolve it as a full username.  If there were no slashes
       // then this might be a partial username.   We try to resolve it as such
       // but after that, we're done regardless of any matches.
       if (FirstSep == llvm::StringRef::npos) {
         llvm::StringSet<> MatchSet;
-        saw_directory = Resolver.ResolvePartial(Username, MatchSet);
+        Resolver.ResolvePartial(Username, MatchSet);
         for (const auto &S : MatchSet) {
           Resolved = S.getKey();
           path::append(Resolved, path::get_separator());
           matches.AppendString(Resolved);
         }
-        saw_directory = (matches.GetSize() > 0);
       }
       return matches.GetSize();
     }
 
     // If there was no trailing slash, then we're done as soon as we resolve
     // the expression to the correct directory.  Otherwise we need to continue
     // looking for matches within that directory.
     if (FirstSep == llvm::StringRef::npos) {
       // Make sure it ends with a separator.
       path::append(CompletionBuffer, path::get_separator());
-      saw_directory = true;
       matches.AppendString(CompletionBuffer);
       return 1;
     }
 
     // We want to keep the form the user typed, so we special case this to
     // search in the fully resolved directory, but CompletionBuffer keeps the
     // unmodified form that the user typed.
     Storage = Resolved;
for (; Iter != End && !EC; Iter.increment(EC)) {
     // Shrink it back down so that it just has the original prefix the user
     // typed and remove the part of the name which is common to the located
     // item and what the user typed.
     CompletionBuffer.resize(FullPrefixLen);
     Name = Name.drop_front(PartialItem.size());
     CompletionBuffer.append(Name);
 
     if (is_dir) {
-      saw_directory = true;
       path::append(CompletionBuffer, path::get_separator());
     }
 
     matches.AppendString(CompletionBuffer);
   }
 
   return matches.GetSize();
 }
 
 int CommandCompletions::DiskFiles(CommandInterpreter &interpreter,
-                                  llvm::StringRef partial_file_name,
-                                  int match_start_point,
-                                  int max_return_elements,
-                                  SearchFilter *searcher, bool &word_complete,
-                                  StringList &matches) {
-  word_complete = false;
+                                  CompletionRequest &request,
+                                  SearchFilter *searcher) {
+  request.SetWordComplete(false);
   StandardTildeExpressionResolver Resolver;
-  return DiskFiles(partial_file_name, matches, Resolver);
+  return DiskFiles(request.GetCursorArgumentPrefix(), request.GetMatches(),
+                   Resolver);
 }
 
 int CommandCompletions::DiskFiles(const llvm::Twine &partial_file_name,
                                   StringList &matches,
                                   TildeExpressionResolver &Resolver) {
-  bool word_complete;
-  int ret_val = DiskFilesOrDirectories(partial_file_name, false, word_complete,
-                                       matches, Resolver);
-  return ret_val;
+  return DiskFilesOrDirectories(partial_file_name, false, matches, Resolver);
 }
 
-int CommandCompletions::DiskDirectories(
-    CommandInterpreter &interpreter, llvm::StringRef partial_file_name,
-    int match_start_point, int max_return_elements, SearchFilter *searcher,
-    bool &word_complete, StringList &matches) {
-  word_complete = false;
+int CommandCompletions::DiskDirectories(CommandInterpreter &interpreter,
+                                        CompletionRequest &request,
+                                        SearchFilter *searcher) {
+  request.SetWordComplete(false);
   StandardTildeExpressionResolver Resolver;
-  return DiskDirectories(partial_file_name, matches, Resolver);
+  return DiskDirectories(request.GetCursorArgumentPrefix(),
+                         request.GetMatches(), Resolver);
 }
 
 int CommandCompletions::DiskDirectories(const llvm::Twine &partial_file_name,
                                         StringList &matches,
                                         TildeExpressionResolver &Resolver) {
-  bool word_complete;
-  int ret_val = DiskFilesOrDirectories(partial_file_name, true, word_complete,
-                                       matches, Resolver);
-  return ret_val;
+  return DiskFilesOrDirectories(partial_file_name, true, matches, Resolver);
 }
 
 int CommandCompletions::Modules(CommandInterpreter &interpreter,
-                                llvm::StringRef partial_file_name,
-                                int match_start_point, int max_return_elements,
-                                SearchFilter *searcher, bool &word_complete,
-                                StringList &matches) {
-  word_complete = true;
-  ModuleCompleter completer(interpreter, partial_file_name, match_start_point,
-                            max_return_elements, matches);
+                                CompletionRequest &request,
+                                SearchFilter *searcher) {
+  request.SetWordComplete(true);
+  ModuleCompleter completer(interpreter, request);
 
   if (searcher == nullptr) {
     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
     completer.DoCompletion(&null_searcher);
   } else {
     completer.DoCompletion(searcher);
   }
-  return matches.GetSize();
+  return request.GetMatches().GetSize();
 }
 
 int CommandCompletions::Symbols(CommandInterpreter &interpreter,
-                                llvm::StringRef partial_file_name,
-                                int match_start_point, int max_return_elements,
-                                SearchFilter *searcher, bool &word_complete,
-                                StringList &matches) {
-  word_complete = true;
-  SymbolCompleter completer(interpreter, partial_file_name, match_start_point,
-                            max_return_elements, matches);
+                                CompletionRequest &request,
+                                SearchFilter *searcher) {
+  request.SetWordComplete(true);
+  SymbolCompleter completer(interpreter, request);
 
   if (searcher == nullptr) {
     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
     completer.DoCompletion(&null_searcher);
   } else {
     completer.DoCompletion(searcher);
   }
-  return matches.GetSize();
+  return request.GetMatches().GetSize();
 }
 
-int CommandCompletions::SettingsNames(
-    CommandInterpreter &interpreter, llvm::StringRef partial_setting_name,
-    int match_start_point, int max_return_elements, SearchFilter *searcher,
-    bool &word_complete, StringList &matches) {
+int CommandCompletions::SettingsNames(CommandInterpreter &interpreter,
+                                      CompletionRequest &request,
+                                      SearchFilter *searcher) {
   // Cache the full setting name list
   static StringList g_property_names;
   if (g_property_names.GetSize() == 0) {
     // Generate the full setting name list on demand
     lldb::OptionValuePropertiesSP properties_sp(
         interpreter.GetDebugger().GetValueProperties());
     if (properties_sp) {
       StreamString strm;
       properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName);
       const std::string &str = strm.GetString();
       g_property_names.SplitIntoLines(str.c_str(), str.size());
     }
   }
 
   size_t exact_matches_idx = SIZE_MAX;
-  const size_t num_matches = g_property_names.AutoComplete(
-      partial_setting_name, matches, exact_matches_idx);
-  word_complete = exact_matches_idx != SIZE_MAX;
+  const size_t num_matches =
+      g_property_names.AutoComplete(request.GetCursorArgumentPrefix(),
+                                    request.GetMatches(), exact_matches_idx);
+  request.SetWordComplete(exact_matches_idx != SIZE_MAX);
   return num_matches;
 }
 
-int CommandCompletions::PlatformPluginNames(
-    CommandInterpreter &interpreter, llvm::StringRef partial_name,
-    int match_start_point, int max_return_elements, SearchFilter *searcher,
-    bool &word_complete, lldb_private::StringList &matches) {
-  const uint32_t num_matches =
-      PluginManager::AutoCompletePlatformName(partial_name, matches);
-  word_complete = num_matches == 1;
+int CommandCompletions::PlatformPluginNames(CommandInterpreter &interpreter,
+                                            CompletionRequest &request,
+                                            SearchFilter *searcher) {
+  const uint32_t num_matches = PluginManager::AutoCompletePlatformName(
+      request.GetCursorArgumentPrefix(), request.GetMatches());
+  request.SetWordComplete(num_matches == 1);
   return num_matches;
 }
 
-int CommandCompletions::ArchitectureNames(
-    CommandInterpreter &interpreter, llvm::StringRef partial_name,
-    int match_start_point, int max_return_elements, SearchFilter *searcher,
-    bool &word_complete, lldb_private::StringList &matches) {
-  const uint32_t num_matches = ArchSpec::AutoComplete(partial_name, matches);
-  word_complete = num_matches == 1;
+int CommandCompletions::ArchitectureNames(CommandInterpreter &interpreter,
+                                          CompletionRequest &request,
+                                          SearchFilter *searcher) {
+  const uint32_t num_matches = ArchSpec::AutoComplete(request);
+  request.SetWordComplete(num_matches == 1);
   return num_matches;
 }
 
-int CommandCompletions::VariablePath(
-    CommandInterpreter &interpreter, llvm::StringRef partial_name,
-    int match_start_point, int max_return_elements, SearchFilter *searcher,
-    bool &word_complete, lldb_private::StringList &matches) {
-  return Variable::AutoComplete(interpreter.GetExecutionContext(), partial_name,
-                                matches, word_complete);
+int CommandCompletions::VariablePath(CommandInterpreter &interpreter,
+                                     CompletionRequest &request,
+                                     SearchFilter *searcher) {
+  return Variable::AutoComplete(interpreter.GetExecutionContext(), request);
 }
 
 CommandCompletions::Completer::Completer(CommandInterpreter &interpreter,
-                                         llvm::StringRef completion_str,
-                                         int match_start_point,
-                                         int max_return_elements,
-                                         StringList &matches)
-    : m_interpreter(interpreter), m_completion_str(completion_str),
-      m_match_start_point(match_start_point),
-      m_max_return_elements(max_return_elements), m_matches(matches) {}
+                                         CompletionRequest &request)
+    : m_interpreter(interpreter), m_request(request) {}
 
 CommandCompletions::Completer::~Completer() = default;
 
 //----------------------------------------------------------------------
 // SourceFileCompleter
 //----------------------------------------------------------------------
 
 CommandCompletions::SourceFileCompleter::SourceFileCompleter(
     CommandInterpreter &interpreter, bool include_support_files,
-    llvm::StringRef completion_str, int match_start_point,
-    int max_return_elements, StringList &matches)
-    : CommandCompletions::Completer(interpreter, completion_str,
-                                    match_start_point, max_return_elements,
-                                    matches),
+    CompletionRequest &request)
+    : CommandCompletions::Completer(interpreter, request),
       m_include_support_files(include_support_files), m_matching_files() {
-  FileSpec partial_spec(m_completion_str, false);
+  FileSpec partial_spec(m_request.GetCursorArgumentPrefix(), false);
   m_file_name = partial_spec.GetFilename().GetCString();
   m_dir_name = partial_spec.GetDirectory().GetCString();
 }
 
 Searcher::Depth CommandCompletions::SourceFileCompleter::GetDepth() {
   return eDepthCompUnit;
 }
 
CommandCompletions::SourceFileCompleter::SearchCallback(SearchFilter &filter,
   return Searcher::eCallbackReturnContinue;
 }
 
 size_t
 CommandCompletions::SourceFileCompleter::DoCompletion(SearchFilter *filter) {
   filter->Search(*this);
   // Now convert the filelist to completions:
   for (size_t i = 0; i < m_matching_files.GetSize(); i++) {
-    m_matches.AppendString(
+    m_request.GetMatches().AppendString(
         m_matching_files.GetFileSpecAtIndex(i).GetFilename().GetCString());
   }
-  return m_matches.GetSize();
+  return m_request.GetMatches().GetSize();
 }
 
 //----------------------------------------------------------------------
 // SymbolCompleter
 //----------------------------------------------------------------------
 
 static bool regex_chars(const char comp) {
   return (comp == '[' || comp == ']' || comp == '(' || comp == ')' ||
           comp == '{' || comp == '}' || comp == '+' || comp == '.' ||
           comp == '*' || comp == '|' || comp == '^' || comp == '$' ||
           comp == '\\' || comp == '?');
 }
 
 CommandCompletions::SymbolCompleter::SymbolCompleter(
-    CommandInterpreter &interpreter, llvm::StringRef completion_str,
-    int match_start_point, int max_return_elements, StringList &matches)
-    : CommandCompletions::Completer(interpreter, completion_str,
-                                    match_start_point, max_return_elements,
-                                    matches) {
+    CommandInterpreter &interpreter, CompletionRequest &request)
+    : CommandCompletions::Completer(interpreter, request) {
   std::string regex_str;
-  if (!completion_str.empty()) {
+  if (!m_request.GetCursorArgumentPrefix().empty()) {
     regex_str.append("^");
-    regex_str.append(completion_str);
+    regex_str.append(m_request.GetCursorArgumentPrefix());
   } else {
     // Match anything since the completion string is empty
     regex_str.append(".");
   }
   std::string::iterator pos =
       find_if(regex_str.begin() + 1, regex_str.end(), regex_chars);
   while (pos < regex_str.end()) {
     pos = regex_str.insert(pos, '\\');
Searcher::CallbackReturn CommandCompletions::SymbolCompleter::SearchCallback(
   }
   return Searcher::eCallbackReturnContinue;
 }
 
 size_t CommandCompletions::SymbolCompleter::DoCompletion(SearchFilter *filter) {
   filter->Search(*this);
   collection::iterator pos = m_match_set.begin(), end = m_match_set.end();
   for (pos = m_match_set.begin(); pos != end; pos++)
-    m_matches.AppendString((*pos).GetCString());
+    m_request.GetMatches().AppendString((*pos).GetCString());
 
-  return m_matches.GetSize();
+  return m_request.GetMatches().GetSize();
 }
 
 //----------------------------------------------------------------------
 // ModuleCompleter
 //----------------------------------------------------------------------
 CommandCompletions::ModuleCompleter::ModuleCompleter(
-    CommandInterpreter &interpreter, llvm::StringRef completion_str,
-    int match_start_point, int max_return_elements, StringList &matches)
-    : CommandCompletions::Completer(interpreter, completion_str,
-                                    match_start_point, max_return_elements,
-                                    matches) {
-  FileSpec partial_spec(m_completion_str, false);
+    CommandInterpreter &interpreter, CompletionRequest &request)
+    : CommandCompletions::Completer(interpreter, request) {
+  FileSpec partial_spec(m_request.GetCursorArgumentPrefix(), false);
   m_file_name = partial_spec.GetFilename().GetCString();
   m_dir_name = partial_spec.GetDirectory().GetCString();
 }
 
 Searcher::Depth CommandCompletions::ModuleCompleter::GetDepth() {
   return eDepthModule;
 }
 
if (m_file_name && cur_file_name &&
         strstr(cur_file_name, m_file_name) == cur_file_name)
       match = true;
 
     if (match && m_dir_name && cur_dir_name &&
         strstr(cur_dir_name, m_dir_name) != cur_dir_name)
       match = false;
 
     if (match) {
-      m_matches.AppendString(cur_file_name);
+      m_request.GetMatches().AppendString(cur_file_name);
     }
   }
   return Searcher::eCallbackReturnContinue;
 }
 
 size_t CommandCompletions::ModuleCompleter::DoCompletion(SearchFilter *filter) {
   filter->Search(*this);
-  return m_matches.GetSize();
+  return m_request.GetMatches().GetSize();
 }

lldb/trunk/source/Commands/CommandObjectCommands.cpp

public:
   const char *GetRepeatCommand(Args &current_command_args,
                                uint32_t index) override {
     return "";
   }
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    auto completion_str = request.GetParsedLine()[request.GetCursorIndex()].ref;
-    completion_str = completion_str.take_front(request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
-        completion_str, request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   class CommandOptions : public Options {
   public:
CommandObjectCommandsScriptImport(CommandInterpreter &interpreter)
     m_arguments.push_back(arg1);
   }
 
   ~CommandObjectCommandsScriptImport() override = default;
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    llvm::StringRef completion_str =
-        request.GetParsedLine()[request.GetCursorIndex()].ref;
-    completion_str = completion_str.take_front(request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
-        completion_str, request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   class CommandOptions : public Options {
   public:

lldb/trunk/source/Commands/CommandObjectFrame.cpp

public:
   ~CommandObjectFrameVariable() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
     // Arguments are the standard source file completer.
-    auto completion_str = request.GetParsedLine()[request.GetCursorIndex()].ref;
-    completion_str = completion_str.take_front(request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eVariablePathCompletion,
-        completion_str, request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 
 protected:
   llvm::StringRef GetScopeString(VariableSP var_sp) {
     if (!var_sp)
       return llvm::StringRef::withNullAsEmpty(nullptr);
 

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

public:
   {
     m_option_group.Append(&m_platform_options, LLDB_OPT_SET_ALL, 1);
     m_option_group.Finalize();
   }
 
   ~CommandObjectPlatformSelect() override = default;
 
   int HandleCompletion(CompletionRequest &request) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()));
-    completion_str.erase(request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
-    CommandCompletions::PlatformPluginNames(
-        GetCommandInterpreter(), completion_str.c_str(),
-        request.GetMatchStartPoint(), request.GetMaxReturnElements(), nullptr,
-        word_complete, request.GetMatches());
-    request.SetWordComplete(word_complete);
+    CommandCompletions::PlatformPluginNames(GetCommandInterpreter(), request,
+                                            nullptr);
     return request.GetMatches().GetSize();
   }
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     if (args.GetArgumentCount() == 1) {
void OptionParsingStarting(ExecutionContext *execution_context) override {
       attach_info.Clear();
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_platform_process_attach_options);
     }
 
     bool HandleOptionArgumentCompletion(
-        Args &input, int cursor_index, int char_pos,
-        OptionElementVector &opt_element_vector, int opt_element_index,
-        int match_start_point, int max_return_elements,
-        CommandInterpreter &interpreter, bool &word_complete,
-        StringList &matches) override {
+        CompletionRequest &request, OptionElementVector &opt_element_vector,
+        int opt_element_index, CommandInterpreter &interpreter) override {
       int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
       int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
 
       // We are only completing the name option for now...
 
       if (GetDefinitions()[opt_defs_index].short_option == 'n') {
         // Are we in the name?
 
         // Look to see if there is a -P argument provided, and if so use that
         // plugin, otherwise use the default plugin.
 
         const char *partial_name = nullptr;
-        partial_name = input.GetArgumentAtIndex(opt_arg_pos);
+        partial_name = request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos);
 
         PlatformSP platform_sp(interpreter.GetPlatform(true));
         if (platform_sp) {
           ProcessInstanceInfoList process_infos;
           ProcessInstanceInfoMatch match_info;
           if (partial_name) {
             match_info.GetProcessInfo().GetExecutableFile().SetFile(
                 partial_name, false, FileSpec::Style::native);
             match_info.SetNameMatchType(NameMatch::StartsWith);
           }
           platform_sp->FindProcesses(match_info, process_infos);
           const uint32_t num_matches = process_infos.GetSize();
           if (num_matches > 0) {
             for (uint32_t i = 0; i < num_matches; ++i) {
-              matches.AppendString(
+              request.GetMatches().AppendString(
                   process_infos.GetProcessNameAtIndex(i),
                   process_infos.GetProcessNameLengthAtIndex(i));
             }
           }
         }
       }
 
       return false;

lldb/trunk/source/Commands/CommandObjectPlugin.cpp

CommandObjectPluginLoad(CommandInterpreter &interpreter)
     m_arguments.push_back(arg1);
   }
 
   ~CommandObjectPluginLoad() override = default;
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    auto completion_str = request.GetParsedLine()[request.GetCursorIndex()].ref;
-    completion_str = completion_str.take_front(request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
-        completion_str, request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     size_t argc = command.GetArgumentCount();
 
     if (argc != 1) {

lldb/trunk/source/Commands/CommandObjectProcess.cpp

CommandObjectProcessLaunch(CommandInterpreter &interpreter)
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectProcessLaunch() override = default;
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()));
-    completion_str.erase(request.GetCursorCharPosition());
 
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
-        completion_str.c_str(), request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 
   Options *GetOptions() override { return &m_options; }
 
   const char *GetRepeatCommand(Args &current_command_args,
                                uint32_t index) override {
     // No repeat for "process launch"...
void OptionParsingStarting(ExecutionContext *execution_context) override {
       attach_info.Clear();
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_process_attach_options);
     }
 
     bool HandleOptionArgumentCompletion(
-        Args &input, int cursor_index, int char_pos,
-        OptionElementVector &opt_element_vector, int opt_element_index,
-        int match_start_point, int max_return_elements,
-        CommandInterpreter &interpreter, bool &word_complete,
-        StringList &matches) override {
+        CompletionRequest &request, OptionElementVector &opt_element_vector,
+        int opt_element_index, CommandInterpreter &interpreter) override {
       int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
       int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
 
       // We are only completing the name option for now...
 
       if (GetDefinitions()[opt_defs_index].short_option == 'n') {
         // Are we in the name?
 
         // Look to see if there is a -P argument provided, and if so use that
         // plugin, otherwise use the default plugin.
 
         const char *partial_name = nullptr;
-        partial_name = input.GetArgumentAtIndex(opt_arg_pos);
+        partial_name = request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos);
 
         PlatformSP platform_sp(interpreter.GetPlatform(true));
         if (platform_sp) {
           ProcessInstanceInfoList process_infos;
           ProcessInstanceInfoMatch match_info;
           if (partial_name) {
             match_info.GetProcessInfo().GetExecutableFile().SetFile(
                 partial_name, false, FileSpec::Style::native);
             match_info.SetNameMatchType(NameMatch::StartsWith);
           }
           platform_sp->FindProcesses(match_info, process_infos);
           const size_t num_matches = process_infos.GetSize();
           if (num_matches > 0) {
             for (size_t i = 0; i < num_matches; ++i) {
-              matches.AppendString(
+              request.GetMatches().AppendString(
                   process_infos.GetProcessNameAtIndex(i),
                   process_infos.GetProcessNameLengthAtIndex(i));
             }
           }
         }
       }
 
       return false;

lldb/trunk/source/Commands/CommandObjectSettings.cpp

public:
     // Instance variables to hold the values for command options.
 
     bool m_global;
   };
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()),
-        request.GetCursorCharPosition());
 
     const size_t argc = request.GetParsedLine().GetArgumentCount();
     const char *arg = nullptr;
     int setting_var_idx;
     for (setting_var_idx = 0; setting_var_idx < static_cast<int>(argc);
          ++setting_var_idx) {
       arg = request.GetParsedLine().GetArgumentAtIndex(setting_var_idx);
       if (arg && arg[0] != '-')
         break; // We found our setting variable name index
     }
     if (request.GetCursorIndex() == setting_var_idx) {
       // Attempting to complete setting variable name
-      bool word_complete = request.GetWordComplete();
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
-          completion_str.c_str(), request.GetMatchStartPoint(),
-          request.GetMaxReturnElements(), nullptr, word_complete,
-          request.GetMatches());
-      request.SetWordComplete(word_complete);
+          request, nullptr);
     } else {
       arg =
           request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex());
 
       if (arg) {
         if (arg[0] == '-') {
           // Complete option name
         } else {
           // Complete setting value
           const char *setting_var_name =
               request.GetParsedLine().GetArgumentAtIndex(setting_var_idx);
           Status error;
           lldb::OptionValueSP value_sp(
               m_interpreter.GetDebugger().GetPropertyValue(
                   &m_exe_ctx, setting_var_name, false, error));
           if (value_sp) {
-            bool word_complete = request.GetWordComplete();
-            value_sp->AutoComplete(m_interpreter, completion_str.c_str(),
-                                   request.GetMatchStartPoint(),
-                                   request.GetMaxReturnElements(),
-                                   word_complete, request.GetMatches());
-            request.SetWordComplete(word_complete);
+            value_sp->AutoComplete(m_interpreter, request);
           }
         }
       }
     }
     return request.GetMatches().GetSize();
   }
 
 protected:
CommandObjectSettingsShow(CommandInterpreter &interpreter)
     m_arguments.push_back(arg1);
   }
 
   ~CommandObjectSettingsShow() override = default;
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()),
-        request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
-        completion_str.c_str(), request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishResult);
 
     if (!args.empty()) {
CommandObjectSettingsList(CommandInterpreter &interpreter)
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectSettingsList() override = default;
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()),
-        request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
-        completion_str.c_str(), request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishResult);
 
     const bool will_modify = false;
CommandObjectSettingsRemove(CommandInterpreter &interpreter)
     m_arguments.push_back(arg2);
   }
 
   ~CommandObjectSettingsRemove() override = default;
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()),
-        request.GetCursorCharPosition());
-
-    // Attempting to complete variable name
-    bool word_complete = request.GetWordComplete();
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
-          completion_str.c_str(), request.GetMatchStartPoint(),
-          request.GetMaxReturnElements(), nullptr, word_complete,
-          request.GetMatches());
-    request.SetWordComplete(word_complete);
+          request, nullptr);
     return request.GetMatches().GetSize();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
public:
 
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()),
-        request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     // Attempting to complete variable name
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
-          completion_str.c_str(), request.GetMatchStartPoint(),
-          request.GetMaxReturnElements(), nullptr, word_complete,
-          request.GetMatches());
-    request.SetWordComplete(word_complete);
+          request, nullptr);
 
     return request.GetMatches().GetSize();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
public:
 
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()),
-        request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     // Attempting to complete variable name
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
-          completion_str.c_str(), request.GetMatchStartPoint(),
-          request.GetMaxReturnElements(), nullptr, word_complete,
-          request.GetMatches());
-    request.SetWordComplete(word_complete);
+          request, nullptr);
 
     return request.GetMatches().GetSize();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
public:
 
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()),
-        request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     // Attempting to complete variable name
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
-          completion_str.c_str(), request.GetMatchStartPoint(),
-          request.GetMaxReturnElements(), nullptr, word_complete,
-          request.GetMatches());
-    request.SetWordComplete(word_complete);
+          request, nullptr);
 
     return request.GetMatches().GetSize();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
public:
 
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()),
-        request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     // Attempting to complete variable name
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
-          completion_str.c_str(), request.GetMatchStartPoint(),
-          request.GetMaxReturnElements(), nullptr, word_complete,
-          request.GetMatches());
-    request.SetWordComplete(word_complete);
+          request, nullptr);
 
     return request.GetMatches().GetSize();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
CommandObjectSettingsClear(CommandInterpreter &interpreter)
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectSettingsClear() override = default;
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()),
-        request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     // Attempting to complete variable name
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
-          completion_str.c_str(), request.GetMatchStartPoint(),
-          request.GetMaxReturnElements(), nullptr, word_complete,
-          request.GetMatches());
-    request.SetWordComplete(word_complete);
+          request, nullptr);
 
     return request.GetMatches().GetSize();
   }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     const size_t argc = command.GetArgumentCount();

lldb/trunk/source/Commands/CommandObjectTarget.cpp

public:
 
   ~CommandObjectTargetCreate() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()));
-    completion_str.erase(request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
-        completion_str.c_str(), request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     FileSpec core_file(m_core_file.GetOptionValue().GetCurrentValue());
     FileSpec remote_file(m_remote_file.GetOptionValue().GetCurrentValue());
CommandObjectTargetModulesModuleAutoComplete(CommandInterpreter &interpreter,
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectTargetModulesModuleAutoComplete() override = default;
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    // Arguments are the standard module completer.
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()));
-    completion_str.erase(request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
-        GetCommandInterpreter(), CommandCompletions::eModuleCompletion,
-        completion_str.c_str(), request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        GetCommandInterpreter(), CommandCompletions::eModuleCompletion, request,
+        nullptr);
     return request.GetMatches().GetSize();
   }
 };
 
 #pragma mark CommandObjectTargetModulesSourceFileAutoComplete
 
 //----------------------------------------------------------------------
 // A base command object class that can auto complete with module source
CommandObjectTargetModulesSourceFileAutoComplete(
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectTargetModulesSourceFileAutoComplete() override = default;
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    // Arguments are the standard source file completer.
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()));
-    completion_str.erase(request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eSourceFileCompletion,
-        completion_str.c_str(), request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 };
 
 #pragma mark CommandObjectTargetModulesDumpObjfile
 
 class CommandObjectTargetModulesDumpObjfile
     : public CommandObjectTargetModulesModuleAutoComplete {
public:
 
   ~CommandObjectTargetModulesAdd() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()));
-    completion_str.erase(request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
-        completion_str.c_str(), request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 
 protected:
   OptionGroupOptions m_option_group;
   OptionGroupUUID m_uuid_option_group;
   OptionGroupFile m_symbol_file;
 
CommandObjectTargetSymbolsAdd(CommandInterpreter &interpreter)
     m_option_group.Finalize();
   }
 
   ~CommandObjectTargetSymbolsAdd() override = default;
 
   int HandleArgumentCompletion(
       CompletionRequest &request,
       OptionElementVector &opt_element_vector) override {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()));
-    completion_str.erase(request.GetCursorCharPosition());
-
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
-        completion_str.c_str(), request.GetMatchStartPoint(),
-        request.GetMaxReturnElements(), nullptr, word_complete,
-        request.GetMatches());
-    request.SetWordComplete(word_complete);
+        request, nullptr);
     return request.GetMatches().GetSize();
   }
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
   bool AddModuleSymbols(Target *target, ModuleSpec &module_spec, bool &flush,
                         CommandReturnObject &result) {

lldb/trunk/source/Core/FormatEntity.cpp

for (size_t i = 0; i < n; ++i) {
       else if (strncmp(def->children[i].name, match_prefix.data(),
                        match_prefix.size()) == 0)
         matches.AppendString(
             MakeMatch(prefix, def->children[i].name + match_prefix.size()));
     }
   }
 }
 
-size_t FormatEntity::AutoComplete(llvm::StringRef str, int match_start_point,
-                                  int max_return_elements, bool &word_complete,
-                                  StringList &matches) {
-  word_complete = false;
-  str = str.drop_front(match_start_point);
-  matches.Clear();
+size_t FormatEntity::AutoComplete(CompletionRequest &request) {
+  llvm::StringRef str = request.GetCursorArgumentPrefix().str();
+
+  request.SetWordComplete(false);
+  str = str.drop_front(request.GetMatchStartPoint());
+  request.GetMatches().Clear();
 
   const size_t dollar_pos = str.rfind('$');
   if (dollar_pos == llvm::StringRef::npos)
     return 0;
 
   // Hitting TAB after $ at the end of the string add a "{"
   if (dollar_pos == str.size() - 1) {
     std::string match = str.str();
     match.append("{");
-    matches.AppendString(match);
+    request.GetMatches().AppendString(match);
     return 1;
   }
 
   if (str[dollar_pos + 1] != '{')
     return 0;
 
   const size_t close_pos = str.find('}', dollar_pos + 2);
   if (close_pos != llvm::StringRef::npos)
     return 0;
 
   const size_t format_pos = str.find('%', dollar_pos + 2);
   if (format_pos != llvm::StringRef::npos)
     return 0;
 
   llvm::StringRef partial_variable(str.substr(dollar_pos + 2));
   if (partial_variable.empty()) {
     // Suggest all top level entites as we are just past "${"
-    AddMatches(&g_root, str, llvm::StringRef(), matches);
-    return matches.GetSize();
+    AddMatches(&g_root, str, llvm::StringRef(), request.GetMatches());
+    return request.GetMatches().GetSize();
   }
 
   // We have a partially specified variable, find it
   llvm::StringRef remainder;
   const FormatEntity::Entry::Definition *entry_def =
       FindEntry(partial_variable, &g_root, remainder);
   if (!entry_def)
     return 0;
 
   const size_t n = entry_def->num_children;
 
   if (remainder.empty()) {
     // Exact match
     if (n > 0) {
       // "${thread.info" <TAB>
-      matches.AppendString(MakeMatch(str, "."));
+      request.GetMatches().AppendString(MakeMatch(str, "."));
     } else {
       // "${thread.id" <TAB>
-      matches.AppendString(MakeMatch(str, "}"));
-      word_complete = true;
+      request.GetMatches().AppendString(MakeMatch(str, "}"));
+      request.SetWordComplete(true);
     }
   } else if (remainder.equals(".")) {
     // "${thread." <TAB>
-    AddMatches(entry_def, str, llvm::StringRef(), matches);
+    AddMatches(entry_def, str, llvm::StringRef(), request.GetMatches());
   } else {
     // We have a partial match
     // "${thre" <TAB>
-    AddMatches(entry_def, str, remainder, matches);
+    AddMatches(entry_def, str, remainder, request.GetMatches());
   }
-  return matches.GetSize();
+  return request.GetMatches().GetSize();
 }

lldb/trunk/source/Core/IOHandler.cpp

case Completion::None:
     break;
 
   case Completion::LLDBCommand:
     return io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion(
         current_line, cursor, last_char, skip_first_n_matches, max_matches,
         matches);
 
   case Completion::Expression: {
-    bool word_complete = false;
-    const char *word_start = cursor;
-    if (cursor > current_line)
-      --word_start;
-    while (word_start > current_line && !isspace(*word_start))
-      --word_start;
+    CompletionRequest request(current_line, current_line - cursor,
+                              skip_first_n_matches, max_matches, matches);
     CommandCompletions::InvokeCommonCompletionCallbacks(
         io_handler.GetDebugger().GetCommandInterpreter(),
-        CommandCompletions::eVariablePathCompletion, word_start,
-        skip_first_n_matches, max_matches, nullptr, word_complete, matches);
+        CommandCompletions::eVariablePathCompletion, request, nullptr);
 
-    size_t num_matches = matches.GetSize();
+    size_t num_matches = request.GetMatches().GetSize();
     if (num_matches > 0) {
       std::string common_prefix;
-      matches.LongestCommonPrefix(common_prefix);
-      const size_t partial_name_len = strlen(word_start);
+      request.GetMatches().LongestCommonPrefix(common_prefix);
+      const size_t partial_name_len = request.GetCursorArgumentPrefix().size();
 
       // If we matched a unique single command, add a space... Only do this if
       // the completer told us this was a complete word, however...
-      if (num_matches == 1 && word_complete) {
+      if (num_matches == 1 && request.GetWordComplete()) {
         common_prefix.push_back(' ');
       }
       common_prefix.erase(0, partial_name_len);
       matches.InsertStringAtIndex(0, std::move(common_prefix));
     }
     return num_matches;
   } break;
   }

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

if (log)
           "HandleCommand, command line after removing command name(s): '%s'",
           remainder.c_str());
 
     cmd_obj->Execute(remainder.c_str(), result);
   } else {
     // We didn't find the first command object, so complete the first argument.
     Args command_args(command_string);
     StringList matches;
-    int cursor_index = 0;
-    int cursor_char_position = strlen(command_args.GetArgumentAtIndex(0));
-    bool word_complete = true;
-    CompletionRequest request(command_line, cursor_char_position, command_args,
-                              cursor_index, cursor_char_position, 0, -1,
-                              word_complete, matches);
+    unsigned cursor_char_position = strlen(command_args.GetArgumentAtIndex(0));
+    CompletionRequest request(command_line, cursor_char_position, 0, -1,
+                              matches);
     int num_matches = HandleCompletionMatches(request);
-    word_complete = request.GetWordComplete();
 
     if (num_matches > 0) {
       std::string error_msg;
       error_msg.assign("ambiguous command '");
       error_msg.append(command_args.GetArgumentAtIndex(0));
       error_msg.append("'.");
 
       error_msg.append(" Possible completions:");
int CommandInterpreter::HandleCompletionMatches(CompletionRequest &request) {
   }
 
   return num_command_matches;
 }
 
 int CommandInterpreter::HandleCompletion(
     const char *current_line, const char *cursor, const char *last_char,
     int match_start_point, int max_return_elements, StringList &matches) {
-  // We parse the argument up to the cursor, so the last argument in
-  // parsed_line is the one containing the cursor, and the cursor is after the
-  // last character.
 
   llvm::StringRef command_line(current_line, last_char - current_line);
-  Args parsed_line(command_line);
-  Args partial_parsed_line(
-      llvm::StringRef(current_line, cursor - current_line));
+  CompletionRequest request(command_line, cursor - current_line,
+                            match_start_point, max_return_elements, matches);
 
   // Don't complete comments, and if the line we are completing is just the
   // history repeat character, substitute the appropriate history line.
-  const char *first_arg = parsed_line.GetArgumentAtIndex(0);
+  const char *first_arg = request.GetParsedLine().GetArgumentAtIndex(0);
   if (first_arg) {
     if (first_arg[0] == m_comment_char)
       return 0;
     else if (first_arg[0] == CommandHistory::g_repeat_char) {
       if (auto hist_str = m_command_history.FindString(first_arg)) {
-        matches.Clear();
-        matches.InsertStringAtIndex(0, *hist_str);
+        request.GetMatches().Clear();
+        request.GetMatches().InsertStringAtIndex(0, *hist_str);
         return -2;
       } else
         return 0;
     }
   }
 
-  int num_args = partial_parsed_line.GetArgumentCount();
-  int cursor_index = partial_parsed_line.GetArgumentCount() - 1;
-  int cursor_char_position;
-
-  if (cursor_index == -1)
-    cursor_char_position = 0;
-  else
-    cursor_char_position =
-        strlen(partial_parsed_line.GetArgumentAtIndex(cursor_index));
-
-  if (cursor > current_line && cursor[-1] == ' ') {
-    // We are just after a space.  If we are in an argument, then we will
-    // continue parsing, but if we are between arguments, then we have to
-    // complete whatever the next element would be. We can distinguish the two
-    // cases because if we are in an argument (e.g. because the space is
-    // protected by a quote) then the space will also be in the parsed
-    // argument...
-
-    const char *current_elem =
-        partial_parsed_line.GetArgumentAtIndex(cursor_index);
-    if (cursor_char_position == 0 ||
-        current_elem[cursor_char_position - 1] != ' ') {
-      parsed_line.InsertArgumentAtIndex(cursor_index + 1, llvm::StringRef(),
-                                        '\0');
-      cursor_index++;
-      cursor_char_position = 0;
-    }
-  }
-
-  int num_command_matches;
-
-  matches.Clear();
-
   // Only max_return_elements == -1 is supported at present:
   lldbassert(max_return_elements == -1);
-  bool word_complete = false;
-
-  CompletionRequest request(command_line, cursor - current_line, parsed_line,
-                            cursor_index, cursor_char_position,
-                            match_start_point, max_return_elements,
-                            word_complete, matches);
 
-  num_command_matches = HandleCompletionMatches(request);
-  word_complete = request.GetWordComplete();
+  int num_command_matches = HandleCompletionMatches(request);
 
   if (num_command_matches <= 0)
     return num_command_matches;
 
-  if (num_args == 0) {
+  if (request.GetParsedLine().GetArgumentCount() == 0) {
     // If we got an empty string, insert nothing.
     matches.InsertStringAtIndex(0, "");
   } else {
     // Now figure out if there is a common substring, and if so put that in
     // element 0, otherwise put an empty string in element 0.
-    std::string command_partial_str;
-    if (cursor_index >= 0)
-      command_partial_str =
-          parsed_line[cursor_index].ref.take_front(cursor_char_position);
+    std::string command_partial_str = request.GetCursorArgumentPrefix().str();
 
     std::string common_prefix;
     matches.LongestCommonPrefix(common_prefix);
     const size_t partial_name_len = command_partial_str.size();
     common_prefix.erase(0, partial_name_len);
 
     // If we matched a unique single command, add a space... Only do this if
     // the completer told us this was a complete word, however...
-    if (num_command_matches == 1 && word_complete) {
-      char quote_char = parsed_line[cursor_index].quote;
+    if (num_command_matches == 1 && request.GetWordComplete()) {
+      char quote_char = request.GetParsedLine()[request.GetCursorIndex()].quote;
       common_prefix =
           Args::EscapeLLDBCommandArgument(common_prefix, quote_char);
       if (quote_char != '\0')
         common_prefix.push_back(quote_char);
       common_prefix.push_back(' ');
     }
-    matches.InsertStringAtIndex(0, common_prefix.c_str());
+    request.GetMatches().InsertStringAtIndex(0, common_prefix.c_str());
   }
   return num_command_matches;
 }
 
 CommandInterpreter::~CommandInterpreter() {}
 
 void CommandInterpreter::UpdatePrompt(llvm::StringRef new_prompt) {
   EventSP prompt_change_event_sp(

lldb/trunk/source/Interpreter/CommandObject.cpp

if (WantsRawCommandString() && !WantsCompletion()) {
     Options *cur_options = GetOptions();
     CommandReturnObject result;
     OptionElementVector opt_element_vector;
 
     if (cur_options != nullptr) {
       opt_element_vector = cur_options->ParseForCompletion(
           request.GetParsedLine(), request.GetCursorIndex());
 
-      bool handled_by_options;
-      bool word_complete = request.GetWordComplete();
-      handled_by_options = cur_options->HandleOptionCompletion(
-          request.GetParsedLine(), opt_element_vector, request.GetCursorIndex(),
-          request.GetCursorCharPosition(), request.GetMatchStartPoint(),
-          request.GetMaxReturnElements(), GetCommandInterpreter(),
-          word_complete, request.GetMatches());
-      request.SetWordComplete(word_complete);
+      bool handled_by_options = cur_options->HandleOptionCompletion(
+          request, opt_element_vector, GetCommandInterpreter());
       if (handled_by_options)
         return request.GetMatches().GetSize();
     }
 
     // If we got here, the last word is not an option or an option argument.
     return HandleArgumentCompletion(request, opt_element_vector);
   }
 }
bool CommandObjectRaw::Execute(const char *args_string,
   }
   return handled;
 }
 
 static llvm::StringRef arch_helper() {
   static StreamString g_archs_help;
   if (g_archs_help.Empty()) {
     StringList archs;
-    ArchSpec::AutoComplete(llvm::StringRef(), archs);
+
+    ArchSpec::ListSupportedArchNames(archs);
     g_archs_help.Printf("These are the supported architecture names:\n");
     archs.Join("\n", g_archs_help);
   }
   return g_archs_help.GetString();
 }
 
 CommandObject::ArgumentTableEntry CommandObject::g_arguments_data[] = {
     // clang-format off

lldb/trunk/source/Interpreter/CommandObjectRegexCommand.cpp

bool CommandObjectRegexCommand::AddRegexCommand(const char *re_cstr,
   }
   // The regex didn't compile...
   m_entries.pop_back();
   return false;
 }
 
 int CommandObjectRegexCommand::HandleCompletion(CompletionRequest &request) {
   if (m_completion_type_mask) {
-    std::string completion_str(
-        request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()),
-        request.GetCursorCharPosition());
-    bool word_complete = request.GetWordComplete();
     CommandCompletions::InvokeCommonCompletionCallbacks(
-        GetCommandInterpreter(), m_completion_type_mask, completion_str.c_str(),
-        request.GetMatchStartPoint(), request.GetMaxReturnElements(), nullptr,
-        word_complete, request.GetMatches());
-    request.SetWordComplete(word_complete);
+        GetCommandInterpreter(), m_completion_type_mask, request, nullptr);
     return request.GetMatches().GetSize();
   } else {
     request.GetMatches().Clear();
     request.SetWordComplete(false);
   }
   return 0;
 }

lldb/trunk/source/Interpreter/OptionValue.cpp

if (name) {
     else
       dumped_something = true;
     strm << name;
   }
   return dumped_something;
 }
 
 size_t OptionValue::AutoComplete(CommandInterpreter &interpreter,
-                                 llvm::StringRef s, int match_start_point,
-                                 int max_return_elements, bool &word_complete,
-                                 StringList &matches) {
-  word_complete = false;
-  matches.Clear();
-  return matches.GetSize();
+                                 CompletionRequest &request) {
+  request.SetWordComplete(false);
+  request.GetMatches().Clear();
+  return request.GetMatches().GetSize();
 }
 
 Status OptionValue::SetValueFromString(llvm::StringRef value,
                                        VarSetOperationType op) {
   Status error;
   switch (op) {
   case eVarSetOperationReplace:
     error.SetErrorStringWithFormat(

lldb/trunk/source/Interpreter/OptionValueArch.cpp

Status OptionValueArch::SetValueFromString(llvm::StringRef value,
   return error;
 }
 
 lldb::OptionValueSP OptionValueArch::DeepCopy() const {
   return OptionValueSP(new OptionValueArch(*this));
 }
 
 size_t OptionValueArch::AutoComplete(CommandInterpreter &interpreter,
-                                     llvm::StringRef s, int match_start_point,
-                                     int max_return_elements,
-                                     bool &word_complete, StringList &matches) {
-  word_complete = false;
-  matches.Clear();
+                                     CompletionRequest &request) {
+  request.SetWordComplete(false);
+  request.GetMatches().Clear();
   CommandCompletions::InvokeCommonCompletionCallbacks(
-      interpreter, CommandCompletions::eArchitectureCompletion, s,
-      match_start_point, max_return_elements, nullptr, word_complete, matches);
-  return matches.GetSize();
+      interpreter, CommandCompletions::eArchitectureCompletion, request,
+      nullptr);
+  return request.GetMatches().GetSize();
 }

lldb/trunk/source/Interpreter/OptionValueBoolean.cpp

Status OptionValueBoolean::SetValueFromString(llvm::StringRef value_str,
   }
   return error;
 }
 
 lldb::OptionValueSP OptionValueBoolean::DeepCopy() const {
   return OptionValueSP(new OptionValueBoolean(*this));
 }
 
-size_t OptionValueBoolean::AutoComplete(
-    CommandInterpreter &interpreter, llvm::StringRef s, int match_start_point,
-    int max_return_elements, bool &word_complete, StringList &matches) {
-  word_complete = false;
-  matches.Clear();
+size_t OptionValueBoolean::AutoComplete(CommandInterpreter &interpreter,
+                                        CompletionRequest &request) {
+  request.SetWordComplete(false);
+  request.GetMatches().Clear();
   static const llvm::StringRef g_autocomplete_entries[] = {
       "true", "false", "on", "off", "yes", "no", "1", "0"};
 
   auto entries = llvm::makeArrayRef(g_autocomplete_entries);
 
   // only suggest "true" or "false" by default
-  if (s.empty())
+  if (request.GetCursorArgumentPrefix().empty())
     entries = entries.take_front(2);
 
   for (auto entry : entries) {
-    if (entry.startswith_lower(s))
-      matches.AppendString(entry);
+    if (entry.startswith_lower(request.GetCursorArgumentPrefix()))
+      request.GetMatches().AppendString(entry);
   }
-  return matches.GetSize();
+  return request.GetMatches().GetSize();
 }

lldb/trunk/source/Interpreter/OptionValueEnumeration.cpp

if (enumerators) {
     m_enumerations.Sort();
   }
 }
 
 lldb::OptionValueSP OptionValueEnumeration::DeepCopy() const {
   return OptionValueSP(new OptionValueEnumeration(*this));
 }
 
-size_t OptionValueEnumeration::AutoComplete(
-    CommandInterpreter &interpreter, llvm::StringRef s, int match_start_point,
-    int max_return_elements, bool &word_complete, StringList &matches) {
-  word_complete = false;
-  matches.Clear();
+size_t OptionValueEnumeration::AutoComplete(CommandInterpreter &interpreter,
+                                            CompletionRequest &request) {
+  request.SetWordComplete(false);
+  request.GetMatches().Clear();
 
   const uint32_t num_enumerators = m_enumerations.GetSize();
-  if (!s.empty()) {
+  if (!request.GetCursorArgumentPrefix().empty()) {
     for (size_t i = 0; i < num_enumerators; ++i) {
       llvm::StringRef name = m_enumerations.GetCStringAtIndex(i).GetStringRef();
-      if (name.startswith(s))
-        matches.AppendString(name);
+      if (name.startswith(request.GetCursorArgumentPrefix()))
+        request.GetMatches().AppendString(name);
     }
   } else {
     // only suggest "true" or "false" by default
     for (size_t i = 0; i < num_enumerators; ++i)
-      matches.AppendString(m_enumerations.GetCStringAtIndex(i).GetStringRef());
+      request.GetMatches().AppendString(
+          m_enumerations.GetCStringAtIndex(i).GetStringRef());
   }
-  return matches.GetSize();
+  return request.GetMatches().GetSize();
 }

lldb/trunk/source/Interpreter/OptionValueFileSpec.cpp

Status OptionValueFileSpec::SetValueFromString(llvm::StringRef value,
   }
   return error;
 }
 
 lldb::OptionValueSP OptionValueFileSpec::DeepCopy() const {
   return OptionValueSP(new OptionValueFileSpec(*this));
 }
 
-size_t OptionValueFileSpec::AutoComplete(
-    CommandInterpreter &interpreter, llvm::StringRef s, int match_start_point,
-    int max_return_elements, bool &word_complete, StringList &matches) {
-  word_complete = false;
-  matches.Clear();
+size_t OptionValueFileSpec::AutoComplete(CommandInterpreter &interpreter,
+                                         CompletionRequest &request) {
+  request.SetWordComplete(false);
+  request.GetMatches().Clear();
   CommandCompletions::InvokeCommonCompletionCallbacks(
-      interpreter, m_completion_mask, s, match_start_point, max_return_elements,
-      nullptr, word_complete, matches);
-  return matches.GetSize();
+      interpreter, m_completion_mask, request, nullptr);
+  return request.GetMatches().GetSize();
 }
 
 const lldb::DataBufferSP &OptionValueFileSpec::GetFileContents() {
   if (m_current_value) {
     const auto file_mod_time = FileSystem::GetModificationTime(m_current_value);
     if (m_data_sp && m_data_mod_time == file_mod_time)
       return m_data_sp;
     m_data_sp = DataBufferLLVM::CreateFromPath(m_current_value.GetPath());
     m_data_mod_time = file_mod_time;
   }
   return m_data_sp;
 }

lldb/trunk/source/Interpreter/OptionValueFormatEntity.cpp

Status OptionValueFormatEntity::SetValueFromString(llvm::StringRef value_str,
   }
   return error;
 }
 
 lldb::OptionValueSP OptionValueFormatEntity::DeepCopy() const {
   return OptionValueSP(new OptionValueFormatEntity(*this));
 }
 
-size_t OptionValueFormatEntity::AutoComplete(
-    CommandInterpreter &interpreter, llvm::StringRef s, int match_start_point,
-    int max_return_elements, bool &word_complete, StringList &matches) {
-  return FormatEntity::AutoComplete(s, match_start_point, max_return_elements,
-                                    word_complete, matches);
+size_t OptionValueFormatEntity::AutoComplete(CommandInterpreter &interpreter,
+                                             CompletionRequest &request) {
+  return FormatEntity::AutoComplete(request);
 }

lldb/trunk/source/Interpreter/OptionValueUUID.cpp

Status OptionValueUUID::SetValueFromString(llvm::StringRef value,
   return error;
 }
 
 lldb::OptionValueSP OptionValueUUID::DeepCopy() const {
   return OptionValueSP(new OptionValueUUID(*this));
 }
 
 size_t OptionValueUUID::AutoComplete(CommandInterpreter &interpreter,
-                                     llvm::StringRef s, int match_start_point,
-                                     int max_return_elements,
-                                     bool &word_complete, StringList &matches) {
-  word_complete = false;
-  matches.Clear();
+                                     CompletionRequest &request) {
+  request.SetWordComplete(false);
+  request.GetMatches().Clear();
   ExecutionContext exe_ctx(interpreter.GetExecutionContext());
   Target *target = exe_ctx.GetTargetPtr();
   if (target) {
+    auto prefix = request.GetCursorArgumentPrefix();
     llvm::SmallVector<uint8_t, 20> uuid_bytes;
-    if (UUID::DecodeUUIDBytesFromString(s, uuid_bytes).empty()) {
+    if (UUID::DecodeUUIDBytesFromString(prefix, uuid_bytes).empty()) {
       const size_t num_modules = target->GetImages().GetSize();
       for (size_t i = 0; i < num_modules; ++i) {
         ModuleSP module_sp(target->GetImages().GetModuleAtIndex(i));
         if (module_sp) {
           const UUID &module_uuid = module_sp->GetUUID();
           if (module_uuid.IsValid()) {
             llvm::ArrayRef<uint8_t> module_bytes = module_uuid.GetBytes();
             if (module_bytes.size() >= uuid_bytes.size() &&
                 module_bytes.take_front(uuid_bytes.size()).equals(uuid_bytes)) {
-              matches.AppendString(module_uuid.GetAsString());
+              request.GetMatches().AppendString(module_uuid.GetAsString());
             }
           }
         }
       }
     }
   }
-  return matches.GetSize();
+  return request.GetMatches().GetSize();
 }

lldb/trunk/source/Interpreter/Options.cpp

for (int i = 0; i < num_levels && !options_are_valid; ++i) {
       if (IsASubset(m_seen_options, union_set))
         options_are_valid = true;
     }
   }
 
   return options_are_valid;
 }
 
-bool Options::HandleOptionCompletion(
-    Args &input, OptionElementVector &opt_element_vector, int cursor_index,
-    int char_pos, int match_start_point, int max_return_elements,
-    CommandInterpreter &interpreter, bool &word_complete,
-    lldb_private::StringList &matches) {
-  word_complete = true;
+bool Options::HandleOptionCompletion(CompletionRequest &request,
+                                     OptionElementVector &opt_element_vector,
+                                     CommandInterpreter &interpreter) {
+  request.SetWordComplete(true);
 
   // For now we just scan the completions to see if the cursor position is in
   // an option or its argument.  Otherwise we'll call HandleArgumentCompletion.
   // In the future we can use completion to validate options as well if we
   // want.
 
   auto opt_defs = GetDefinitions();
 
-  std::string cur_opt_std_str(input.GetArgumentAtIndex(cursor_index));
-  cur_opt_std_str.erase(char_pos);
+  std::string cur_opt_std_str = request.GetCursorArgumentPrefix().str();
   const char *cur_opt_str = cur_opt_std_str.c_str();
 
   for (size_t i = 0; i < opt_element_vector.size(); i++) {
     int opt_pos = opt_element_vector[i].opt_pos;
     int opt_arg_pos = opt_element_vector[i].opt_arg_pos;
     int opt_defs_index = opt_element_vector[i].opt_defs_index;
-    if (opt_pos == cursor_index) {
+    if (opt_pos == request.GetCursorIndex()) {
       // We're completing the option itself.
 
       if (opt_defs_index == OptionArgElement::eBareDash) {
         // We're completing a bare dash.  That means all options are open.
         // FIXME: We should scan the other options provided and only complete
         // options
         // within the option group they belong to.
         char opt_str[3] = {'-', 'a', '\0'};
 
         for (auto &def : opt_defs) {
           if (!def.short_option)
             continue;
           opt_str[1] = def.short_option;
-          matches.AppendString(opt_str);
+          request.GetMatches().AppendString(opt_str);
         }
 
         return true;
       } else if (opt_defs_index == OptionArgElement::eBareDoubleDash) {
         std::string full_name("--");
         for (auto &def : opt_defs) {
           if (!def.short_option)
             continue;
 
           full_name.erase(full_name.begin() + 2, full_name.end());
           full_name.append(def.long_option);
-          matches.AppendString(full_name.c_str());
+          request.GetMatches().AppendString(full_name.c_str());
         }
         return true;
       } else if (opt_defs_index != OptionArgElement::eUnrecognizedArg) {
         // We recognized it, if it an incomplete long option, complete it
         // anyway (getopt_long_only is happy with shortest unique string, but
         // it's still a nice thing to do.)  Otherwise return The string so the
         // upper level code will know this is a full match and add the " ".
         if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
             cur_opt_str[1] == '-' &&
             strcmp(opt_defs[opt_defs_index].long_option, cur_opt_str) != 0) {
           std::string full_name("--");
           full_name.append(opt_defs[opt_defs_index].long_option);
-          matches.AppendString(full_name.c_str());
+          request.GetMatches().AppendString(full_name.c_str());
           return true;
         } else {
-          matches.AppendString(input.GetArgumentAtIndex(cursor_index));
+          request.GetMatches().AppendString(request.GetCursorArgument());
           return true;
         }
       } else {
         // FIXME - not handling wrong options yet:
         // Check to see if they are writing a long option & complete it.
         // I think we will only get in here if the long option table has two
         // elements
         // that are not unique up to this point.  getopt_long_only does
         // shortest unique match for long options already.
 
         if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
             cur_opt_str[1] == '-') {
           for (auto &def : opt_defs) {
             if (!def.long_option)
               continue;
 
             if (strstr(def.long_option, cur_opt_str + 2) == def.long_option) {
               std::string full_name("--");
               full_name.append(def.long_option);
               // The options definitions table has duplicates because of the
               // way the grouping information is stored, so only add once.
               bool duplicate = false;
-              for (size_t k = 0; k < matches.GetSize(); k++) {
-                if (matches.GetStringAtIndex(k) == full_name) {
+              for (size_t k = 0; k < request.GetMatches().GetSize(); k++) {
+                if (request.GetMatches().GetStringAtIndex(k) == full_name) {
                   duplicate = true;
                   break;
                 }
               }
               if (!duplicate)
-                matches.AppendString(full_name.c_str());
+                request.GetMatches().AppendString(full_name.c_str());
             }
           }
         }
         return true;
       }
 
-    } else if (opt_arg_pos == cursor_index) {
+    } else if (opt_arg_pos == request.GetCursorIndex()) {
       // Okay the cursor is on the completion of an argument. See if it has a
       // completion, otherwise return no matches.
 
+      CompletionRequest subrequest = request;
+      subrequest.SetCursorCharPosition(subrequest.GetCursorArgument().size());
       if (opt_defs_index != -1) {
-        HandleOptionArgumentCompletion(
-            input, cursor_index, strlen(input.GetArgumentAtIndex(cursor_index)),
-            opt_element_vector, i, match_start_point, max_return_elements,
-            interpreter, word_complete, matches);
+        HandleOptionArgumentCompletion(subrequest, opt_element_vector, i,
+                                       interpreter);
+        request.SetWordComplete(subrequest.GetWordComplete());
         return true;
       } else {
         // No completion callback means no completions...
         return true;
       }
 
     } else {
       // Not the last element, keep going.
       continue;
     }
   }
   return false;
 }
 
 bool Options::HandleOptionArgumentCompletion(
-    Args &input, int cursor_index, int char_pos,
-    OptionElementVector &opt_element_vector, int opt_element_index,
-    int match_start_point, int max_return_elements,
-    CommandInterpreter &interpreter, bool &word_complete,
-    lldb_private::StringList &matches) {
+    CompletionRequest &request, OptionElementVector &opt_element_vector,
+    int opt_element_index, CommandInterpreter &interpreter) {
   auto opt_defs = GetDefinitions();
   std::unique_ptr<SearchFilter> filter_ap;
 
   int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
   int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
 
   // See if this is an enumeration type option, and if so complete it here:
 
   OptionEnumValueElement *enum_values = opt_defs[opt_defs_index].enum_values;
   if (enum_values != nullptr) {
     bool return_value = false;
-    std::string match_string(input.GetArgumentAtIndex(opt_arg_pos),
-                             input.GetArgumentAtIndex(opt_arg_pos) + char_pos);
+    std::string match_string(
+        request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos),
+        request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos) +
+            request.GetCursorCharPosition());
     for (int i = 0; enum_values[i].string_value != nullptr; i++) {
       if (strstr(enum_values[i].string_value, match_string.c_str()) ==
           enum_values[i].string_value) {
-        matches.AppendString(enum_values[i].string_value);
+        request.GetMatches().AppendString(enum_values[i].string_value);
         return_value = true;
       }
     }
     return return_value;
   }
 
   // If this is a source file or symbol type completion, and  there is a -shlib
   // option somewhere in the supplied arguments, then make a search filter for
for (size_t i = 0; i < opt_element_vector.size(); i++) {
 
       int cur_arg_pos = opt_element_vector[i].opt_arg_pos;
       const char *cur_opt_name = opt_defs[cur_defs_index].long_option;
 
       // If this is the "shlib" option and there was an argument provided,
       // restrict it to that shared library.
       if (cur_opt_name && strcmp(cur_opt_name, "shlib") == 0 &&
           cur_arg_pos != -1) {
-        const char *module_name = input.GetArgumentAtIndex(cur_arg_pos);
+        const char *module_name =
+            request.GetParsedLine().GetArgumentAtIndex(cur_arg_pos);
         if (module_name) {
           FileSpec module_spec(module_name, false);
           lldb::TargetSP target_sp =
               interpreter.GetDebugger().GetSelectedTarget();
           // Search filters require a target...
           if (target_sp)
             filter_ap.reset(new SearchFilterByModule(target_sp, module_spec));
         }
         break;
       }
     }
   }
 
   return CommandCompletions::InvokeCommonCompletionCallbacks(
-      interpreter, completion_mask, input.GetArgumentAtIndex(opt_arg_pos),
-      match_start_point, max_return_elements, filter_ap.get(), word_complete,
-      matches);
+      interpreter, completion_mask, request, filter_ap.get());
 }
 
 void OptionGroupOptions::Append(OptionGroup *group) {
   auto group_option_defs = group->GetDefinitions();
   for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
     m_option_infos.push_back(OptionInfo(group, i));
     m_option_defs.push_back(group_option_defs[i]);
   }

lldb/trunk/source/Symbol/Variable.cpp

default:
         }
       }
       break;
     }
   }
 }
 
 size_t Variable::AutoComplete(const ExecutionContext &exe_ctx,
-                              llvm::StringRef partial_path, StringList &matches,
-                              bool &word_complete) {
-  word_complete = false;
+                              CompletionRequest &request) {
   CompilerType compiler_type;
 
-  PrivateAutoComplete(exe_ctx.GetFramePtr(), partial_path, "", compiler_type,
-                      matches, word_complete);
+  bool word_complete = false;
+  PrivateAutoComplete(exe_ctx.GetFramePtr(), request.GetCursorArgumentPrefix(),
+                      "", compiler_type, request.GetMatches(), word_complete);
+  request.SetWordComplete(word_complete);
 
-  return matches.GetSize();
+  return request.GetMatches().GetSize();
 }

lldb/trunk/source/Utility/ArchSpec.cpp

 
 struct ArchDefinition {
   ArchitectureType type;
   size_t num_entries;
   const ArchDefinitionEntry *entries;
   const char *name;
 };
 
-size_t ArchSpec::AutoComplete(llvm::StringRef name, StringList &matches) {
-  if (!name.empty()) {
+void ArchSpec::ListSupportedArchNames(StringList &list) {
+  for (uint32_t i = 0; i < llvm::array_lengthof(g_core_definitions); ++i)
+    list.AppendString(g_core_definitions[i].name);
+}
+
+size_t ArchSpec::AutoComplete(CompletionRequest &request) {
+  if (!request.GetCursorArgumentPrefix().empty()) {
     for (uint32_t i = 0; i < llvm::array_lengthof(g_core_definitions); ++i) {
-      if (NameMatches(g_core_definitions[i].name, NameMatch::StartsWith, name))
-        matches.AppendString(g_core_definitions[i].name);
+      if (NameMatches(g_core_definitions[i].name, NameMatch::StartsWith,
+                      request.GetCursorArgumentPrefix()))
+        request.GetMatches().AppendString(g_core_definitions[i].name);
     }
   } else {
-    for (uint32_t i = 0; i < llvm::array_lengthof(g_core_definitions); ++i)
-      matches.AppendString(g_core_definitions[i].name);
+    ListSupportedArchNames(request.GetMatches());
   }
-  return matches.GetSize();
+  return request.GetMatches().GetSize();
 }
 
 #define CPU_ANY (UINT32_MAX)
 
 //===----------------------------------------------------------------------===//
 // A table that gets searched linearly for matches. This table is used to
 // convert cpu type and subtypes to architecture names, and to convert
 // architecture names to cpu types and subtypes. The ordering is important and

lldb/trunk/source/Utility/CompletionRequest.cpp

 //===-- CompletionRequest.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/CompletionRequest.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-CompletionRequest::CompletionRequest(llvm::StringRef command,
-                                     unsigned raw_cursor_pos, Args &parsed_line,
-                                     int cursor_index, int cursor_char_position,
+CompletionRequest::CompletionRequest(llvm::StringRef command_line,
+                                     unsigned raw_cursor_pos,
                                      int match_start_point,
                                      int max_return_elements,
-                                     bool word_complete, StringList &matches)
-    : m_command(command), m_raw_cursor_pos(raw_cursor_pos),
-      m_parsed_line(parsed_line), m_cursor_index(cursor_index),
-      m_cursor_char_position(cursor_char_position),
+                                     StringList &matches)
+    : m_command(command_line), m_raw_cursor_pos(raw_cursor_pos),
       m_match_start_point(match_start_point),
-      m_max_return_elements(max_return_elements),
-      m_word_complete(word_complete), m_matches(&matches) {}
+      m_max_return_elements(max_return_elements), m_matches(&matches) {
+
+  // We parse the argument up to the cursor, so the last argument in
+  // parsed_line is the one containing the cursor, and the cursor is after the
+  // last character.
+  m_parsed_line = Args(command_line);
+  m_partial_parsed_line = Args(command_line.substr(0, raw_cursor_pos));
+
+  m_cursor_index = m_partial_parsed_line.GetArgumentCount() - 1;
+
+  if (m_cursor_index == -1)
+    m_cursor_char_position = 0;
+  else
+    m_cursor_char_position =
+        strlen(m_partial_parsed_line.GetArgumentAtIndex(m_cursor_index));
+
+  matches.Clear();
+
+  const char *cursor = command_line.data() + raw_cursor_pos;
+  if (raw_cursor_pos > 0 && cursor[-1] == ' ') {
+    // We are just after a space.  If we are in an argument, then we will
+    // continue parsing, but if we are between arguments, then we have to
+    // complete whatever the next element would be. We can distinguish the two
+    // cases because if we are in an argument (e.g. because the space is
+    // protected by a quote) then the space will also be in the parsed
+    // argument...
+
+    const char *current_elem =
+        m_partial_parsed_line.GetArgumentAtIndex(m_cursor_index);
+    if (m_cursor_char_position == 0 ||
+        current_elem[m_cursor_char_position - 1] != ' ') {
+      m_parsed_line.InsertArgumentAtIndex(m_cursor_index + 1, llvm::StringRef(),
+                                          '\0');
+      m_cursor_index++;
+      m_cursor_char_position = 0;
+    }
+  }
+}

lldb/trunk/unittests/Utility/CompletionRequestTest.cpp

 //===-- CompletionRequestTest.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "lldb/Utility/CompletionRequest.h"
 using namespace lldb_private;
 
 TEST(CompletionRequest, Constructor) {
-  std::string command = "a b";
-  const unsigned cursor_pos = 2;
-  Args args(command);
+  std::string command = "a bad c";
+  const unsigned cursor_pos = 3;
   const int arg_index = 1;
-  const int arg_cursor_pos = 0;
+  const int arg_cursor_pos = 1;
   const int match_start = 2345;
   const int match_max_return = 12345;
-  bool word_complete = false;
   StringList matches;
-  CompletionRequest request(command, cursor_pos, args, arg_index,
-                            arg_cursor_pos, match_start, match_max_return,
-                            word_complete, matches);
+
+  CompletionRequest request(command, cursor_pos, match_start, match_max_return,
+                            matches);
 
   EXPECT_STREQ(request.GetRawLine().str().c_str(), command.c_str());
   EXPECT_EQ(request.GetRawCursorPos(), cursor_pos);
   EXPECT_EQ(request.GetCursorIndex(), arg_index);
   EXPECT_EQ(request.GetCursorCharPosition(), arg_cursor_pos);
   EXPECT_EQ(request.GetMatchStartPoint(), match_start);
   EXPECT_EQ(request.GetMaxReturnElements(), match_max_return);
-  EXPECT_EQ(request.GetWordComplete(), word_complete);
+  EXPECT_EQ(request.GetWordComplete(), false);
+
+  EXPECT_EQ(request.GetPartialParsedLine().GetArgumentCount(), 2u);
+  EXPECT_STREQ(request.GetPartialParsedLine().GetArgumentAtIndex(1), "b");
+
   // This is the generated matches should be equal to our passed string list.
   EXPECT_EQ(&request.GetMatches(), &matches);
 }