[lldb][NFC] Remove WordComplete mode, make result array indexed from 0 and remove any undocumented/redundant return values

[teemperor]

Summary

We still have some leftovers of the old completion API in the internals of
LLDB that haven't been replaced by the new CompletionRequest. These leftovers
are:

• The return values (int/size_t) in all completion functions.
• Our result array that starts indexing at 1.
• WordComplete mode.

I didn't replace them back then because it's tricky to figure out what exactly they
are used for and the completion code is relatively untested. I finally got around
to writing more tests for the API and understanding the semantics, so I think it's
a good time to get rid of them.

A few words why those things should be removed/replaced:

• The return values are really cryptic, partly redundant and rarely documented. They are also completely ignored by Xcode, so whatever information they contain will end up breaking Xcode's completion mechanism. They are also partly impossible to even implement as we assign negative values special meaning and our completion API sometimes returns size_t.
  
  Completion functions are supposed to return -2 to rewrite the current line. We seem to use this in some untested code path to expand the history repeat character to the full command, but I haven't figured out why that doesn't work at the moment. Completion functions return -1 to 'insert the completion character', but that isn't implemented (even though we seem to activate this feature in LLDB sometimes). All positive values have to match the number of results. This is obviously just redundant information as the user can just look at the result list to get that information (which is what Xcode does).

• The result array that starts indexing at 1 is obviously unexpected. The first element of the array is reserved for the common prefix of all completions (e.g. "foobar" and "footar" -> "foo"). The idea is that we calculate this to make the life of the API caller easier, but obviously forcing people to have 1-based indices is not helpful (or even worse, forces them to manually copy the results to make it 0-based like Xcode has to do).

• The WordComplete mode indicates that LLDB should enter a space behind the completion. The idea is that we let the top-level API know that we just provided a full completion. Interestingly we WordComplete is just a single bool that somehow represents all N completions. And we always provide full completions in LLDB, so in theory it should always be true. The only use it currently serves is providing redundant information about whether we have a single definitive completion or not (which we already know from the number of results we get).

This patch essentially removes WordComplete mode and makes the result array indexed from 0.
It also removes all return values from all internal completion functions. The only non-redundant information
they contain is about rewriting the current line (which is broken), so that functionality was moved
to the CompletionRequest API. So you can now do addCompletion("blub", "description", CompletionMode::RewriteLine)
to do the same.

For the SB API we emulate the old behaviour by making the array indexed from 1 again with the common
prefix at index 0. I didn't keep the special negative return codes as we either never sent them before (e.g. -2) or we
didn't even implement them in the Editline handler (e.g. -1).

I tried to keep this patch minimal and I'm aware we can probably now even further simplify a bunch of related code,
but I would prefer doing this in follow-up NFC commits

[teemperor]

• Add comment that we emulate the old API by adding the common prefix as element 0.

[teemperor]

lldb/source/Interpreter/CommandInterpreter.cpp

1847 ↗

(On Diff #216398)

Note that I moved this code to SBCommandInterpreter::HandleCompletionWithDescriptions (as it adds the common prefix in element 0).

[JDevlieghere]

Thanks for cleaning this up, Raphael!

lldb/source/API/SBCommandInterpreter.cpp

379 ↗

(On Diff #216398)

Maybe add that this is here to emulate old behavior that our clients rely on.

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

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(lldb_private::CompletionRequest &request);
+  static void 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.
   static bool FormatFileSpec(const FileSpec &file, Stream &s,

lldb/trunk/include/lldb/Core/IOHandler.h

IOHandlerDelegate(Completion completion = Completion::None)
       : m_completion(completion) {}
 
   virtual ~IOHandlerDelegate() = default;
 
   virtual void IOHandlerActivated(IOHandler &io_handler, bool interactive) {}
 
   virtual void IOHandlerDeactivated(IOHandler &io_handler) {}
 
-  virtual int IOHandlerComplete(IOHandler &io_handler,
+  virtual void IOHandlerComplete(IOHandler &io_handler,
                                  CompletionRequest &request);
 
   virtual const char *IOHandlerGetFixIndentationCharacters() { return nullptr; }
 
   /// Called when a new line is created or one of an identified set of
   /// indentation characters is typed.
   ///
   /// This function determines how much indentation should be added
   /// or removed to match the recommended amount for the final line.

 private:
 #ifndef LLDB_DISABLE_LIBEDIT
   static bool IsInputCompleteCallback(Editline *editline, StringList &lines,
                                       void *baton);
 
   static int FixIndentationCallback(Editline *editline, const StringList &lines,
                                     int cursor_position, void *baton);
 
-  static int AutoCompleteCallback(CompletionRequest &request, void *baton);
+  static void AutoCompleteCallback(CompletionRequest &request, void *baton);
 #endif
 
 protected:
 #ifndef LLDB_DISABLE_LIBEDIT
   std::unique_ptr<Editline> m_editline_up;
 #endif
   IOHandlerDelegate &m_delegate;
   std::string m_prompt;

 public:
   IOHandlerConfirm(Debugger &debugger, llvm::StringRef prompt,
                    bool default_response);
 
   ~IOHandlerConfirm() override;
 
   bool GetResponse() const { return m_user_response; }
 
-  int IOHandlerComplete(IOHandler &io_handler,
+  void IOHandlerComplete(IOHandler &io_handler,
                          CompletionRequest &request) override;
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override;
 
 protected:
   const bool m_default_response;
   bool m_user_response;
 };

lldb/trunk/include/lldb/Core/PluginManager.h

 //===-- PluginManager.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_PluginManager_h_
 #define liblldb_PluginManager_h_
 
 #include "lldb/Core/Architecture.h"
+#include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private-interfaces.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <stddef.h>
public:
 
   static PlatformCreateInstance
   GetPlatformCreateCallbackForPluginName(ConstString name);
 
   static const char *GetPlatformPluginNameAtIndex(uint32_t idx);
 
   static const char *GetPlatformPluginDescriptionAtIndex(uint32_t idx);
 
-  static size_t AutoCompletePlatformName(llvm::StringRef partial_name,
-                                         StringList &matches);
+  static void AutoCompletePlatformName(llvm::StringRef partial_name,
+                                       CompletionRequest &request);
   // Process
   static bool
   RegisterPlugin(ConstString name, const char *description,
                  ProcessCreateInstance create_callback,
                  DebuggerInitializeCallback debugger_init_callback = nullptr);
 
   static bool UnregisterPlugin(ProcessCreateInstance create_callback);
 

lldb/trunk/include/lldb/Expression/REPL.h

bool IOHandlerIsInputComplete(IOHandler &io_handler,
                                 StringList &lines) override;
 
   int IOHandlerFixIndentation(IOHandler &io_handler, const StringList &lines,
                               int cursor_position) override;
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &line) override;
 
-  int IOHandlerComplete(IOHandler &io_handler,
+  void IOHandlerComplete(IOHandler &io_handler,
                          CompletionRequest &request) override;
 
 protected:
   static int CalculateActualIndentation(const StringList &lines);
 
   // Subclasses should override these functions to implement a functional REPL.
 
   virtual Status DoInitialization() = 0;
 

lldb/trunk/include/lldb/Host/Editline.h

 
 typedef bool (*IsInputCompleteCallbackType)(Editline *editline,
                                             StringList &lines, void *baton);
 
 typedef int (*FixIndentationCallbackType)(Editline *editline,
                                           const StringList &lines,
                                           int cursor_position, void *baton);
 
-typedef int (*CompleteCallbackType)(CompletionRequest &request, void *baton);
+typedef void (*CompleteCallbackType)(CompletionRequest &request, void *baton);
 
 /// Status used to decide when and how to start editing another line in
 /// multi-line sessions
 enum class EditorStatus {
 
   /// The default state proceeds to edit the current line
   Editing,
 

lldb/trunk/include/lldb/Interpreter/CommandAlias.h

public:
   bool IsValid() const { return m_underlying_command_sp && m_option_args_sp; }
 
   explicit operator bool() const { return IsValid(); }
 
   bool WantsRawCommandString() override;
 
   bool WantsCompletion() override;
 
-  int HandleCompletion(CompletionRequest &request) override;
+  void HandleCompletion(CompletionRequest &request) override;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override;
 
   Options *GetOptions() override;
 
   bool IsAlias() override { return true; }
 
   bool IsDashDashCommand() override;
 
   llvm::StringRef GetHelp() override;

lldb/trunk/include/lldb/Interpreter/CommandCompletions.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,
+  typedef void (*CompletionCallback)(CommandInterpreter &interpreter,
                                      CompletionRequest &request,
                                      // A search filter to limit the search...
                                      lldb_private::SearchFilter *searcher);
   enum CommonCompletionTypes {
     eNoCompletion = 0u,
     eSourceFileCompletion = (1u << 0),
     eDiskFileCompletion = (1u << 1),
     eDiskDirectoryCompletion = (1u << 2),
     eSymbolCompletion = (1u << 3),
     eModuleCompletion = (1u << 4),
     eSettingsNameCompletion = (1u << 5),
struct CommonCompletionElement {
     CompletionCallback callback;
   };
 
   static bool InvokeCommonCompletionCallbacks(
       CommandInterpreter &interpreter, uint32_t completion_mask,
       lldb_private::CompletionRequest &request, SearchFilter *searcher);
 
   // These are the generic completer functions:
-  static int DiskFiles(CommandInterpreter &interpreter,
+  static void DiskFiles(CommandInterpreter &interpreter,
                         CompletionRequest &request, SearchFilter *searcher);
 
-  static int DiskFiles(const llvm::Twine &partial_file_name,
+  static void DiskFiles(const llvm::Twine &partial_file_name,
                         StringList &matches, TildeExpressionResolver &Resolver);
 
-  static int DiskDirectories(CommandInterpreter &interpreter,
+  static void DiskDirectories(CommandInterpreter &interpreter,
                               CompletionRequest &request,
                               SearchFilter *searcher);
 
-  static int DiskDirectories(const llvm::Twine &partial_file_name,
+  static void DiskDirectories(const llvm::Twine &partial_file_name,
                               StringList &matches,
                               TildeExpressionResolver &Resolver);
 
-  static int SourceFiles(CommandInterpreter &interpreter,
+  static void SourceFiles(CommandInterpreter &interpreter,
                           CompletionRequest &request, SearchFilter *searcher);
 
-  static int Modules(CommandInterpreter &interpreter,
+  static void Modules(CommandInterpreter &interpreter,
                       CompletionRequest &request, SearchFilter *searcher);
 
-  static int Symbols(CommandInterpreter &interpreter,
+  static void Symbols(CommandInterpreter &interpreter,
                       CompletionRequest &request, SearchFilter *searcher);
 
-  static int SettingsNames(CommandInterpreter &interpreter,
+  static void SettingsNames(CommandInterpreter &interpreter,
                             CompletionRequest &request, SearchFilter *searcher);
 
-  static int PlatformPluginNames(CommandInterpreter &interpreter,
+  static void PlatformPluginNames(CommandInterpreter &interpreter,
                                   CompletionRequest &request,
                                   SearchFilter *searcher);
 
-  static int ArchitectureNames(CommandInterpreter &interpreter,
+  static void ArchitectureNames(CommandInterpreter &interpreter,
                                 CompletionRequest &request,
                                 SearchFilter *searcher);
 
-  static int VariablePath(CommandInterpreter &interpreter,
+  static void VariablePath(CommandInterpreter &interpreter,
                            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, CompletionRequest &request);
 
     ~Completer() override;
 
     CallbackReturn SearchCallback(SearchFilter &filter, SymbolContext &context,
                                   Address *addr, bool complete) override = 0;
 
     lldb::SearchDepth GetDepth() override = 0;
 
-    virtual size_t DoCompletion(SearchFilter *filter) = 0;
+    virtual void DoCompletion(SearchFilter *filter) = 0;
 
   protected:
     CommandInterpreter &m_interpreter;
     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, CompletionRequest &request);
 
     lldb::SearchDepth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
                                             Address *addr,
                                             bool complete) override;
 
-    size_t DoCompletion(SearchFilter *filter) override;
+    void DoCompletion(SearchFilter *filter) override;
 
   private:
     bool m_include_support_files;
     FileSpecList m_matching_files;
     const char *m_file_name;
     const char *m_dir_name;
 
     DISALLOW_COPY_AND_ASSIGN(SourceFileCompleter);
   };
 
   // ModuleCompleter implements the module completer
   class ModuleCompleter : public Completer {
   public:
     ModuleCompleter(CommandInterpreter &interpreter,
                     CompletionRequest &request);
 
     lldb::SearchDepth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
                                             Address *addr,
                                             bool complete) override;
 
-    size_t DoCompletion(SearchFilter *filter) override;
+    void 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,
                     CompletionRequest &request);
 
     lldb::SearchDepth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
                                             Address *addr,
                                             bool complete) override;
 
-    size_t DoCompletion(SearchFilter *filter) override;
+    void DoCompletion(SearchFilter *filter) override;
 
   private:
     RegularExpression m_regex;
     typedef std::set<ConstString> collection;
     collection m_match_set;
 
     DISALLOW_COPY_AND_ASSIGN(SymbolCompleter);
   };
 
 private:
   static CommonCompletionElement g_common_completions[];
 };
 
 } // namespace lldb_private
 
 #endif // lldb_CommandCompletions_h_

lldb/trunk/include/lldb/Interpreter/CommandInterpreter.h

public:
   ///    and failed with some explanation if we aborted executing the commands
   ///    at some point.
   void HandleCommandsFromFile(FileSpec &file, ExecutionContext *context,
                               CommandInterpreterRunOptions &options,
                               CommandReturnObject &result);
 
   CommandObject *GetCommandObjectForCommand(llvm::StringRef &command_line);
 
-  // This handles command line completion. Returns: -1
-  // if the completion character should be inserted -2 if the entire command
-  // line should be deleted and replaced with matches.GetStringAtIndex(0)
-  // INT_MAX if the number of matches is > max_return_elements, but it is
-  // expensive to compute. Otherwise, returns the number of matches.
-  //
-  // FIXME: Only max_return_elements == -1 is supported at present.
-  int HandleCompletion(CompletionRequest &request);
+  // This handles command line completion.
+  void HandleCompletion(CompletionRequest &request);
 
   // This version just returns matches, and doesn't compute the substring. It
   // is here so the Help command can call it for the first argument.
-  int HandleCompletionMatches(CompletionRequest &request);
+  void HandleCompletionMatches(CompletionRequest &request);
 
   int GetCommandNamesMatchingPartialString(const char *cmd_cstr,
                                            bool include_aliases,
                                            StringList &matches,
                                            StringList &descriptions);
 
   void GetHelp(CommandReturnObject &result,
                uint32_t types = eCommandTypesAllThem);

lldb/trunk/include/lldb/Interpreter/CommandObject.h

public:
   /// instead unless you have special reasons.
   ///
   /// \param[in/out] request
   ///    The completion request that needs to be answered.
   ///
   /// 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 int HandleCompletion(CompletionRequest &request);
+  virtual void HandleCompletion(CompletionRequest &request);
 
   /// The input array contains a parsed version of the line.  The insertion
   /// point is given by cursor_index (the index in input of the word containing
   /// the cursor) and cursor_char_position (the position of the cursor in that
   /// word.)
   /// We've constructed the map of options and their arguments as well if that
   /// is helpful for the completion.
   ///
   /// \param[in/out] request
   ///    The completion request that needs to be answered.
   ///
   /// 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
-  ///     The number of completions.
-  virtual int
+  virtual void
   HandleArgumentCompletion(CompletionRequest &request,
-                           OptionElementVector &opt_element_vector) {
-    return 0;
-  }
+                           OptionElementVector &opt_element_vector) {}
 
   bool HelpTextContainsWord(llvm::StringRef search_word,
                             bool search_short_help = true,
                             bool search_long_help = true,
                             bool search_syntax = true,
                             bool search_options = true);
 
   /// The flags accessor.

lldb/trunk/include/lldb/Interpreter/CommandObjectMultiword.h

public:
 
   void AproposAllSubCommands(llvm::StringRef prefix,
                              llvm::StringRef search_word,
                              StringList &commands_found,
                              StringList &commands_help) override;
 
   bool WantsRawCommandString() override { return false; }
 
-  int HandleCompletion(CompletionRequest &request) override;
+  void HandleCompletion(CompletionRequest &request) override;
 
   const char *GetRepeatCommand(Args &current_command_args,
                                uint32_t index) override;
 
   bool Execute(const char *args_string, CommandReturnObject &result) override;
 
   bool IsRemovable() const override { return m_can_be_removed; }
 
bool LoadSubCommand(llvm::StringRef cmd_name,
                       const lldb::CommandObjectSP &command_obj) override;
 
   bool WantsRawCommandString() override;
 
   bool WantsCompletion() override;
 
   Options *GetOptions() override;
 
-  int HandleCompletion(CompletionRequest &request) override;
+  void HandleCompletion(CompletionRequest &request) override;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override;
 
   const char *GetRepeatCommand(Args &current_command_args,
                                uint32_t index) override;
 
   bool Execute(const char *args_string, CommandReturnObject &result) override;
 
 protected:
   // These two want to iterate over the subcommand dictionary.
   friend class CommandInterpreter;
   friend class CommandObjectSyntax;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_CommandObjectMultiword_h_

lldb/trunk/include/lldb/Interpreter/CommandObjectRegexCommand.h

public:
   ~CommandObjectRegexCommand() override;
 
   bool IsRemovable() const override { return m_is_removable; }
 
   bool AddRegexCommand(const char *re_cstr, const char *command_cstr);
 
   bool HasRegexEntries() const { return !m_entries.empty(); }
 
-  int HandleCompletion(CompletionRequest &request) override;
+  void HandleCompletion(CompletionRequest &request) override;
 
 protected:
   bool DoExecute(llvm::StringRef command, CommandReturnObject &result) override;
 
   struct Entry {
     RegularExpression regex;
     std::string command;
   };

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

public:
   virtual Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign);
 
   virtual bool Clear() = 0;
 
   virtual lldb::OptionValueSP DeepCopy() const = 0;
 
-  virtual size_t AutoComplete(CommandInterpreter &interpreter,
-                              CompletionRequest &request);
+  virtual void AutoComplete(CommandInterpreter &interpreter,
 
   // Subclasses can override these functions
   virtual lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
                                           llvm::StringRef name,
                                           bool will_modify,
                                           Status &error) const {
     error.SetErrorStringWithFormat("'%s' is not a value subvalue", name.str().c_str());
     return lldb::OptionValueSP();

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,
-                      lldb_private::CompletionRequest &request) override;
+  void AutoComplete(CommandInterpreter &interpreter,
 
   // Subclass specific functions
 
   ArchSpec &GetCurrentValue() { return m_current_value; }
 
   const ArchSpec &GetCurrentValue() const { return m_current_value; }
 
   const ArchSpec &GetDefaultValue() const { return m_default_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,
-                      CompletionRequest &request) override;
+  void AutoComplete(CommandInterpreter &interpreter,
 
   // Subclass specific functions
 
   /// Convert to bool operator.
   ///
   /// This allows code to check a OptionValueBoolean in conditions.
   ///
   /// \code

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,
-                      CompletionRequest &request) override;
+  void AutoComplete(CommandInterpreter &interpreter,
 
   // 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,
-                      CompletionRequest &request) override;
+  void AutoComplete(CommandInterpreter &interpreter,
 
   // Subclass specific functions
 
   FileSpec &GetCurrentValue() { return m_current_value; }
 
   const FileSpec &GetCurrentValue() const { return m_current_value; }
 
   const FileSpec &GetDefaultValue() const { return m_default_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,
-                      CompletionRequest &request) override;
+  void AutoComplete(CommandInterpreter &interpreter,
 
   // Subclass specific functions
 
   FormatEntity::Entry &GetCurrentValue() { return m_current_entry; }
 
   const FormatEntity::Entry &GetCurrentValue() const { return m_current_entry; }
 
   void SetCurrentValue(const FormatEntity::Entry &value) {

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

public:
   // Subclass specific functions
 
   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,
-                      CompletionRequest &request) override;
+  void AutoComplete(CommandInterpreter &interpreter,
 
 protected:
   UUID m_uuid;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionValueUUID_h_

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

public:
   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,
-                             CompletionRequest &request);
+  static void AutoComplete(const ExecutionContext &exe_ctx,
 
   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

public:
   const ArchSpec &operator=(const ArchSpec &rhs);
 
   /// 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 void ListSupportedArchNames(StringList &list);
-  static size_t AutoComplete(CompletionRequest &request);
+  static void AutoComplete(CompletionRequest &request);
 
   /// Returns a static string representing the current architecture.
   ///
   /// \return A static string corresponding to the current
   ///         architecture.
   const char *GetArchitectureName() const;
 
   /// if MIPS architecture return true.

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

 
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/StringList.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 
 namespace lldb_private {
+enum class CompletionMode {
+  Normal,
+  // The full line has been rewritten by the completion.
+  RewriteLine,
+};
+
 class CompletionResult {
+public:
   /// A single completion and all associated data.
-  struct Completion {
-    Completion(llvm::StringRef completion, llvm::StringRef description)
-        : m_completion(completion.str()), m_descripton(description.str()) {}
+  class Completion {
 
     std::string m_completion;
     std::string m_descripton;
+    CompletionMode m_mode;
+
+  public:
+    Completion(llvm::StringRef completion, llvm::StringRef description,
+               CompletionMode mode)
+        : m_completion(completion.str()), m_descripton(description.str()),
+          m_mode(mode) {}
+    const std::string &GetCompletion() const { return m_completion; }
+    const std::string &GetDescription() const { return m_descripton; }
+    CompletionMode GetMode() const { return m_mode; }
 
     /// Generates a string that uniquely identifies this completion result.
     std::string GetUniqueKey() const;
   };
+
+private:
   std::vector<Completion> m_results;
 
   /// List of added completions so far. Used to filter out duplicates.
   llvm::StringSet<> m_added_values;
 
 public:
-  void AddResult(llvm::StringRef completion, llvm::StringRef description);
+  void AddResult(llvm::StringRef completion, llvm::StringRef description,
+                 CompletionMode mode);
+
+  llvm::ArrayRef<Completion> GetResults() const { return m_results; }
 
   /// Adds all collected completion matches to the given list.
   /// The list will be cleared before the results are added. The number of
   /// results here is guaranteed to be equal to GetNumberOfResults().
   void GetMatches(StringList &matches) const;
 
   /// Adds all collected completion descriptions to the given list.
   /// The list will be cleared before the results are added. The number of
public:
   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; }
 
+  const Args::ArgEntry &GetParsedArg() {
+    return GetParsedLine()[GetCursorIndex()];
+  }
+
   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; }
 
-  bool GetWordComplete() { return m_word_complete; }
-
-  void SetWordComplete(bool v) { m_word_complete = v; }
-
   /// Adds a possible completion string. If the completion was already
   /// suggested before, it will not be added to the list of results. A copy of
   /// the suggested completion is stored, so the given string can be free'd
   /// afterwards.
   ///
   /// \param match The suggested completion.
   /// \param match An optional description of the completion string. The
   ///     description will be displayed to the user alongside the completion.
   void AddCompletion(llvm::StringRef completion,
-                     llvm::StringRef description = "") {
-    m_result.AddResult(completion, description);
+                     llvm::StringRef description = "",
+                     CompletionMode mode = CompletionMode::Normal) {
+    m_result.AddResult(completion, description, mode);
   }
 
   /// Adds multiple possible completion strings.
   ///
   /// \param completions The list of completions.
   ///
   /// \see AddCompletion
   void AddCompletions(const StringList &completions) {
public:
   void AddCompletions(const StringList &completions,
                       const StringList &descriptions) {
     lldbassert(completions.GetSize() == descriptions.GetSize());
     for (std::size_t i = 0; i < completions.GetSize(); ++i)
       AddCompletion(completions.GetStringAtIndex(i),
                     descriptions.GetStringAtIndex(i));
   }
 
-  std::size_t GetNumberOfMatches() const {
-    return m_result.GetNumberOfResults();
-  }
-
   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;
-  /// \btrue if this is a complete option value (a space will be inserted
-  /// after the completion.)  \bfalse otherwise.
-  bool m_word_complete = false;
 
   /// The result this request is supposed to fill out.
   /// We keep this object private to ensure that no backend can in any way
   /// depend on already calculated completions (which would make debugging and
   /// testing them much more complicated).
   CompletionResult &m_result;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_COMPLETIONREQUEST_H

lldb/trunk/source/API/SBCommandInterpreter.cpp

int SBCommandInterpreter::HandleCompletionWithDescriptions(
     SBStringList &descriptions) {
   LLDB_RECORD_METHOD(int, SBCommandInterpreter,
                      HandleCompletionWithDescriptions,
                      (const char *, const char *, const char *, int, int,
                       lldb::SBStringList &, lldb::SBStringList &),
                      current_line, cursor, last_char, match_start_point,
                      max_return_elements, matches, descriptions);
 
-  int num_completions = 0;
-
   // Sanity check the arguments that are passed in: cursor & last_char have to
   // be within the current_line.
   if (current_line == nullptr || cursor == nullptr || last_char == nullptr)
     return 0;
 
   if (cursor < current_line || last_char < current_line)
     return 0;
 
   size_t current_line_size = strlen(current_line);
   if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) ||
       last_char - current_line > static_cast<ptrdiff_t>(current_line_size))
     return 0;
 
+  if (!IsValid())
+    return 0;
 
-  if (IsValid()) {
-    lldb_private::StringList lldb_matches, lldb_descriptions;
-    CompletionResult result;
-    CompletionRequest request(current_line, cursor - current_line, result);
-    num_completions = m_opaque_ptr->HandleCompletion(request);
-    result.GetMatches(lldb_matches);
-    result.GetDescriptions(lldb_descriptions);
+  m_opaque_ptr->HandleCompletion(request);
 
-    SBStringList temp_matches_list(&lldb_matches);
-    matches.AppendList(temp_matches_list);
-    SBStringList temp_descriptions_list(&lldb_descriptions);
-    descriptions.AppendList(temp_descriptions_list);
-  }
-
-  return num_completions;
+  // Make the result array indexed from 1 again by adding the 'common prefix'
+  // of all completions as element 0. This is done to emulate the old API.
+  if (request.GetParsedLine().GetArgumentCount() == 0) {
+    // If we got an empty string, insert nothing.
+    lldb_matches.InsertStringAtIndex(0, "");
+    lldb_descriptions.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 = request.GetCursorArgumentPrefix().str();
+
+    std::string common_prefix = lldb_matches.LongestCommonPrefix();
+    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 (lldb_matches.GetSize() == 1) {
+      char quote_char = request.GetParsedArg().quote;
+      common_prefix =
+          Args::EscapeLLDBCommandArgument(common_prefix, quote_char);
+      if (request.GetParsedArg().IsQuoted())
+        common_prefix.push_back(quote_char);
+      common_prefix.push_back(' ');
+    }
+    lldb_matches.InsertStringAtIndex(0, common_prefix.c_str());
+    lldb_descriptions.InsertStringAtIndex(0, "");
+  }
+
+  return result.GetNumberOfResults();
 }
 
 int SBCommandInterpreter::HandleCompletionWithDescriptions(
     const char *current_line, uint32_t cursor_pos, int match_start_point,
     int max_return_elements, SBStringList &matches,
     SBStringList &descriptions) {
   LLDB_RECORD_METHOD(int, SBCommandInterpreter,
                      HandleCompletionWithDescriptions,

lldb/trunk/source/Commands/CommandCompletions.cpp

else if ((g_common_completions[i].type & completion_mask) ==
              g_common_completions[i].callback != nullptr) {
       handled = true;
       g_common_completions[i].callback(interpreter, request, searcher);
     }
   }
   return handled;
 }
 
-int CommandCompletions::SourceFiles(CommandInterpreter &interpreter,
+void CommandCompletions::SourceFiles(CommandInterpreter &interpreter,
                                      CompletionRequest &request,
                                      SearchFilter *searcher) {
-  request.SetWordComplete(true);
   // Find some way to switch "include support files..."
   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 request.GetNumberOfMatches();
 }
 
-static int DiskFilesOrDirectories(const llvm::Twine &partial_name,
+static void DiskFilesOrDirectories(const llvm::Twine &partial_name,
                                    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)
-    return matches.GetSize();
+    return;
 
   namespace path = llvm::sys::path;
 
   llvm::StringRef SearchDir;
   llvm::StringRef PartialItem;
 
   if (CompletionBuffer.startswith("~")) {
     llvm::StringRef Buffer(CompletionBuffer);
if (!Resolver.ResolveExact(Username, Resolved)) {
         llvm::StringSet<> MatchSet;
         Resolver.ResolvePartial(Username, MatchSet);
         for (const auto &S : MatchSet) {
           Resolved = S.getKey();
           path::append(Resolved, path::get_separator());
           matches.AppendString(Resolved);
         }
       }
-      return matches.GetSize();
+      return;
     }
 
     // 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());
       matches.AppendString(CompletionBuffer);
-      return matches.GetSize();
+      return;
     }
 
     // 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;
     llvm::StringRef RemainderDir = path::parent_path(Remainder);
     if (!RemainderDir.empty()) {
for (; Iter != End && !EC; Iter.increment(EC)) {
     CompletionBuffer.append(Name);
 
     if (is_dir) {
       path::append(CompletionBuffer, path::get_separator());
     }
 
     matches.AppendString(CompletionBuffer);
   }
-
-  return matches.GetSize();
 }
 
-static int DiskFilesOrDirectories(CompletionRequest &request,
+static void DiskFilesOrDirectories(CompletionRequest &request,
                                    bool only_directories) {
-  request.SetWordComplete(false);
   StandardTildeExpressionResolver resolver;
   StringList matches;
   DiskFilesOrDirectories(request.GetCursorArgumentPrefix(), only_directories,
                          matches, resolver);
   request.AddCompletions(matches);
-  return request.GetNumberOfMatches();
 }
 
-int CommandCompletions::DiskFiles(CommandInterpreter &interpreter,
+void CommandCompletions::DiskFiles(CommandInterpreter &interpreter,
                                    CompletionRequest &request,
                                    SearchFilter *searcher) {
-  return DiskFilesOrDirectories(request, /*only_dirs*/ false);
+  DiskFilesOrDirectories(request, /*only_dirs*/ false);
 }
 
-int CommandCompletions::DiskFiles(const llvm::Twine &partial_file_name,
+void CommandCompletions::DiskFiles(const llvm::Twine &partial_file_name,
                                    StringList &matches,
                                    TildeExpressionResolver &Resolver) {
-  return DiskFilesOrDirectories(partial_file_name, false, matches, Resolver);
+  DiskFilesOrDirectories(partial_file_name, false, matches, Resolver);
 }
 
-int CommandCompletions::DiskDirectories(CommandInterpreter &interpreter,
+void CommandCompletions::DiskDirectories(CommandInterpreter &interpreter,
                                          CompletionRequest &request,
                                          SearchFilter *searcher) {
-  return DiskFilesOrDirectories(request, /*only_dirs*/ true);
+  DiskFilesOrDirectories(request, /*only_dirs*/ true);
 }
 
-int CommandCompletions::DiskDirectories(const llvm::Twine &partial_file_name,
+void CommandCompletions::DiskDirectories(const llvm::Twine &partial_file_name,
                                          StringList &matches,
                                          TildeExpressionResolver &Resolver) {
-  return DiskFilesOrDirectories(partial_file_name, true, matches, Resolver);
+  DiskFilesOrDirectories(partial_file_name, true, matches, Resolver);
 }
 
-int CommandCompletions::Modules(CommandInterpreter &interpreter,
+void CommandCompletions::Modules(CommandInterpreter &interpreter,
                                  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 request.GetNumberOfMatches();
 }
 
-int CommandCompletions::Symbols(CommandInterpreter &interpreter,
+void CommandCompletions::Symbols(CommandInterpreter &interpreter,
                                  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 request.GetNumberOfMatches();
 }
 
-int CommandCompletions::SettingsNames(CommandInterpreter &interpreter,
+void 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());
     }
   }
 
-  bool exact_match = false;
-
   for (const std::string &s : g_property_names) {
-    if (llvm::StringRef(s).startswith(request.GetCursorArgumentPrefix())) {
-      if (request.GetCursorArgumentPrefix() == s)
-        exact_match = true;
+    if (llvm::StringRef(s).startswith(request.GetCursorArgumentPrefix()))
       request.AddCompletion(s);
-    }
-  }
 
-  request.SetWordComplete(exact_match);
-
-  return request.GetNumberOfMatches();
-}
-
-int CommandCompletions::PlatformPluginNames(CommandInterpreter &interpreter,
+void CommandCompletions::PlatformPluginNames(CommandInterpreter &interpreter,
                                              CompletionRequest &request,
                                              SearchFilter *searcher) {
-  StringList new_matches;
-  std::size_t num_matches = PluginManager::AutoCompletePlatformName(
-      request.GetCursorArgumentPrefix(), new_matches);
-  request.SetWordComplete(num_matches == 1);
-  request.AddCompletions(new_matches);
-  return request.GetNumberOfMatches();
+  PluginManager::AutoCompletePlatformName(request.GetCursorArgumentPrefix(),
+                                          request);
 }
 
-int CommandCompletions::ArchitectureNames(CommandInterpreter &interpreter,
+void CommandCompletions::ArchitectureNames(CommandInterpreter &interpreter,
                                            CompletionRequest &request,
                                            SearchFilter *searcher) {
-  const uint32_t num_matches = ArchSpec::AutoComplete(request);
-  request.SetWordComplete(num_matches == 1);
-  return num_matches;
+  ArchSpec::AutoComplete(request);
 }
 
-int CommandCompletions::VariablePath(CommandInterpreter &interpreter,
+void CommandCompletions::VariablePath(CommandInterpreter &interpreter,
                                       CompletionRequest &request,
                                       SearchFilter *searcher) {
-  return Variable::AutoComplete(interpreter.GetExecutionContext(), request);
+  Variable::AutoComplete(interpreter.GetExecutionContext(), request);
 }
 
 CommandCompletions::Completer::Completer(CommandInterpreter &interpreter,
                                          CompletionRequest &request)
     : m_interpreter(interpreter), m_request(request) {}
 
 CommandCompletions::Completer::~Completer() = default;
 
if (m_include_support_files) {
       if (match) {
         m_matching_files.AppendIfUnique(context.comp_unit);
       }
     }
   }
   return Searcher::eCallbackReturnContinue;
 }
 
-size_t
-CommandCompletions::SourceFileCompleter::DoCompletion(SearchFilter *filter) {
+void 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_request.AddCompletion(
         m_matching_files.GetFileSpecAtIndex(i).GetFilename().GetCString());
   }
-  return m_request.GetNumberOfMatches();
 }
 
 // SymbolCompleter
 
 static bool regex_chars(const char comp) {
   return (comp == '[' || comp == ']' || comp == '(' || comp == ')' ||
           comp == '{' || comp == '}' || comp == '+' || comp == '.' ||
           comp == '*' || comp == '|' || comp == '^' || comp == '$' ||
for (uint32_t i = 0; i < sc_list.GetSize(); i++) {
         if (!func_name.IsEmpty() && m_regex.Execute(func_name.GetStringRef()))
           m_match_set.insert(func_name);
       }
     }
   }
   return Searcher::eCallbackReturnContinue;
 }
 
-size_t CommandCompletions::SymbolCompleter::DoCompletion(SearchFilter *filter) {
+void 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_request.AddCompletion((*pos).GetCString());
-
-  return m_request.GetNumberOfMatches();
 }
 
 // ModuleCompleter
 CommandCompletions::ModuleCompleter::ModuleCompleter(
     CommandInterpreter &interpreter, CompletionRequest &request)
     : CommandCompletions::Completer(interpreter, request) {
   FileSpec partial_spec(m_request.GetCursorArgumentPrefix());
   m_file_name = partial_spec.GetFilename().GetCString();
if (context.module_sp) {
 
     if (match) {
       m_request.AddCompletion(cur_file_name);
     }
   }
   return Searcher::eCallbackReturnContinue;
 }
 
-size_t CommandCompletions::ModuleCompleter::DoCompletion(SearchFilter *filter) {
+void CommandCompletions::ModuleCompleter::DoCompletion(SearchFilter *filter) {
   filter->Search(*this);
-  return m_request.GetNumberOfMatches();
 }

lldb/trunk/source/Commands/CommandObjectCommands.cpp

public:
 
   ~CommandObjectCommandsSource() override = default;
 
   const char *GetRepeatCommand(Args &current_command_args,
                                uint32_t index) override {
     return "";
   }
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   class CommandOptions : public Options {
   public:
     CommandOptions()
CommandObjectCommandsScriptImport(CommandInterpreter &interpreter)
     arg1.push_back(cmd_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg1);
   }
 
   ~CommandObjectCommandsScriptImport() override = default;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}

lldb/trunk/source/Commands/CommandObjectExpression.h

public:
   };
 
   CommandObjectExpression(CommandInterpreter &interpreter);
 
   ~CommandObjectExpression() override;
 
   Options *GetOptions() override;
 
-  int HandleCompletion(CompletionRequest &request) override;
+  void HandleCompletion(CompletionRequest &request) override;
 
 protected:
   // IOHandler::Delegate functions
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &line) override;
 
   bool IOHandlerIsInputComplete(IOHandler &io_handler,
                                 StringList &lines) override;

lldb/trunk/source/Commands/CommandObjectExpression.cpp

Examples:
   m_option_group.Append(&m_repl_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_3);
   m_option_group.Finalize();
 }
 
 CommandObjectExpression::~CommandObjectExpression() = default;
 
 Options *CommandObjectExpression::GetOptions() { return &m_option_group; }
 
-int CommandObjectExpression::HandleCompletion(CompletionRequest &request) {
+void CommandObjectExpression::HandleCompletion(CompletionRequest &request) {
   EvaluateExpressionOptions options;
   options.SetCoerceToId(m_varobj_options.use_objc);
   options.SetLanguage(m_command_options.language);
   options.SetExecutionPolicy(lldb_private::eExecutionPolicyNever);
   options.SetAutoApplyFixIts(false);
   options.SetGenerateDebugInfo(false);
 
   // We need a valid execution context with a frame pointer for this
   // completion, so if we don't have one we should try to make a valid
   // execution context.
   if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr)
     m_interpreter.UpdateExecutionContext(nullptr);
 
   // This didn't work, so let's get out before we start doing things that
   // expect a valid frame pointer.
   if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr)
-    return 0;
+    return;
 
   ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
 
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     target = GetDummyTarget();
 
   if (!target)
-    return 0;
+    return;
 
   unsigned cursor_pos = request.GetRawCursorPos();
   llvm::StringRef code = request.GetRawLine();
 
   const std::size_t original_code_size = code.size();
 
   // Remove the first token which is 'expr' or some alias/abbreviation of that.
   code = llvm::getToken(code).second.ltrim();
   OptionsWithRaw args(code);
   code = args.GetRawPart();
 
   // The position where the expression starts in the command line.
   assert(original_code_size >= code.size());
   std::size_t raw_start = original_code_size - code.size();
 
   // Check if the cursor is actually in the expression string, and if not, we
   // exit.
   // FIXME: We should complete the options here.
   if (cursor_pos < raw_start)
-    return 0;
+    return;
 
   // Make the cursor_pos again relative to the start of the code string.
   assert(cursor_pos >= raw_start);
   cursor_pos -= raw_start;
 
   auto language = exe_ctx.GetFrameRef().GetLanguage();
 
   Status error;
   lldb::UserExpressionSP expr(target->GetUserExpressionForLanguage(
       code, llvm::StringRef(), language, UserExpression::eResultTypeAny,
       options, nullptr, error));
   if (error.Fail())
-    return 0;
+    return;
 
   expr->Complete(exe_ctx, request, cursor_pos);
-  return request.GetNumberOfMatches();
 }
 
 static lldb_private::Status
 CanBeUsedForElementCountPrinting(ValueObject &valobj) {
   CompilerType type(valobj.GetCompilerType());
   CompilerType pointee;
   if (!type.IsPointerType(&pointee))
     return Status("as it does not refer to a pointer");

lldb/trunk/source/Commands/CommandObjectFrame.cpp

CommandObjectFrameVariable(CommandInterpreter &interpreter)
     m_option_group.Append(&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Finalize();
   }
 
   ~CommandObjectFrameVariable() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     // Arguments are the standard source file completer.
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eVariablePathCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
 protected:
   llvm::StringRef GetScopeString(VariableSP var_sp) {
     if (!var_sp)
       return llvm::StringRef::withNullAsEmpty(nullptr);
 
     switch (var_sp->GetScope()) {

lldb/trunk/source/Commands/CommandObjectHelp.h

 // CommandObjectHelp
 
 class CommandObjectHelp : public CommandObjectParsed {
 public:
   CommandObjectHelp(CommandInterpreter &interpreter);
 
   ~CommandObjectHelp() override;
 
-  int HandleCompletion(CompletionRequest &request) override;
+  void HandleCompletion(CompletionRequest &request) override;
 
   static void GenerateAdditionalHelpAvenuesMessage(
       Stream *s, llvm::StringRef command, llvm::StringRef prefix,
       llvm::StringRef subcommand, bool include_upropos = true,
       bool include_type_lookup = true);
 
   class CommandOptions : public Options {
   public:

lldb/trunk/source/Commands/CommandObjectHelp.cpp

if (cmd_obj != nullptr) {
         result.SetStatus(eReturnStatusFailed);
       }
     }
   }
 
   return result.Succeeded();
 }
 
-int CommandObjectHelp::HandleCompletion(CompletionRequest &request) {
+void CommandObjectHelp::HandleCompletion(CompletionRequest &request) {
   // Return the completions of the commands in the help system:
   if (request.GetCursorIndex() == 0) {
-    return m_interpreter.HandleCompletionMatches(request);
+    m_interpreter.HandleCompletionMatches(request);
   } else {
     CommandObject *cmd_obj =
         m_interpreter.GetCommandObject(request.GetParsedLine()[0].ref);
 
     // The command that they are getting help on might be ambiguous, in which
     // case we should complete that, otherwise complete with the command the
     // user is getting help on...
 
     if (cmd_obj) {
       request.GetParsedLine().Shift();
       request.SetCursorIndex(request.GetCursorIndex() - 1);
-      return cmd_obj->HandleCompletion(request);
+      cmd_obj->HandleCompletion(request);
     } else {
-      return m_interpreter.HandleCompletionMatches(request);
+      m_interpreter.HandleCompletionMatches(request);
     }
   }
 }

lldb/trunk/source/Commands/CommandObjectMultiword.cpp

if (pos->second->WantsRawCommandString()) {
                                             indented_command.c_str(), "--",
                                             pos->second->GetHelp(), max_len);
   }
 
   output_stream.PutCString("\nFor more help on any particular subcommand, type "
                            "'help <command> <subcommand>'.\n");
 }
 
-int CommandObjectMultiword::HandleCompletion(CompletionRequest &request) {
-  // Any of the command matches will provide a complete word, otherwise the
-  // individual completers will override this.
-  request.SetWordComplete(true);
-
+void CommandObjectMultiword::HandleCompletion(CompletionRequest &request) {
   auto arg0 = request.GetParsedLine()[0].ref;
   if (request.GetCursorIndex() == 0) {
     StringList new_matches, descriptions;
     AddNamesMatchingPartialString(m_subcommand_dict, arg0, new_matches,
                                   &descriptions);
     request.AddCompletions(new_matches, descriptions);
 
     if (new_matches.GetSize() == 1 &&
         new_matches.GetStringAtIndex(0) != nullptr &&
         (arg0 == new_matches.GetStringAtIndex(0))) {
       StringList temp_matches;
       CommandObject *cmd_obj = GetSubcommandObject(arg0, &temp_matches);
       if (cmd_obj != nullptr) {
-        if (request.GetParsedLine().GetArgumentCount() == 1) {
-          request.SetWordComplete(true);
-        } else {
+        if (request.GetParsedLine().GetArgumentCount() != 1) {
           request.GetParsedLine().Shift();
           request.SetCursorCharPosition(0);
           request.GetParsedLine().AppendArgument(llvm::StringRef());
-          return cmd_obj->HandleCompletion(request);
+          cmd_obj->HandleCompletion(request);
         }
       }
     }
-    return new_matches.GetSize();
   } else {
     StringList new_matches;
     CommandObject *sub_command_object = GetSubcommandObject(arg0, &new_matches);
     if (sub_command_object == nullptr) {
       request.AddCompletions(new_matches);
-      return request.GetNumberOfMatches();
     } else {
       // Remove the one match that we got from calling GetSubcommandObject.
       new_matches.DeleteStringAtIndex(0);
       request.AddCompletions(new_matches);
       request.GetParsedLine().Shift();
       request.SetCursorIndex(request.GetCursorIndex() - 1);
       return sub_command_object->HandleCompletion(request);
     }

 
 Options *CommandObjectProxy::GetOptions() {
   CommandObject *proxy_command = GetProxyCommandObject();
   if (proxy_command)
     return proxy_command->GetOptions();
   return nullptr;
 }
 
-int CommandObjectProxy::HandleCompletion(CompletionRequest &request) {
+void CommandObjectProxy::HandleCompletion(CompletionRequest &request) {
   CommandObject *proxy_command = GetProxyCommandObject();
   if (proxy_command)
-    return proxy_command->HandleCompletion(request);
-  return 0;
+    proxy_command->HandleCompletion(request);
 }
 
-int CommandObjectProxy::HandleArgumentCompletion(
+void CommandObjectProxy::HandleArgumentCompletion(
     CompletionRequest &request, OptionElementVector &opt_element_vector) {
   CommandObject *proxy_command = GetProxyCommandObject();
   if (proxy_command)
-    return proxy_command->HandleArgumentCompletion(request, opt_element_vector);
-  return 0;
+    proxy_command->HandleArgumentCompletion(request, opt_element_vector);
 }
 
 const char *CommandObjectProxy::GetRepeatCommand(Args &current_command_args,
                                                  uint32_t index) {
   CommandObject *proxy_command = GetProxyCommandObject();
   if (proxy_command)
     return proxy_command->GetRepeatCommand(current_command_args, index);
   return nullptr;

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

CommandObjectPlatformSelect(CommandInterpreter &interpreter)
             false) // Don't include the "--platform" option by passing false
   {
     m_option_group.Append(&m_platform_options, LLDB_OPT_SET_ALL, 1);
     m_option_group.Finalize();
   }
 
   ~CommandObjectPlatformSelect() override = default;
 
-  int HandleCompletion(CompletionRequest &request) override {
+  void HandleCompletion(CompletionRequest &request) override {
     CommandCompletions::PlatformPluginNames(GetCommandInterpreter(), request,
                                             nullptr);
-    return request.GetNumberOfMatches();
   }
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     if (args.GetArgumentCount() == 1) {
       const char *platform_name = args.GetArgumentAtIndex(0);

lldb/trunk/source/Commands/CommandObjectPlugin.cpp

CommandObjectPluginLoad(CommandInterpreter &interpreter)
     arg1.push_back(cmd_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg1);
   }
 
   ~CommandObjectPluginLoad() override = default;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     size_t argc = command.GetArgumentCount();
 
     if (argc != 1) {
       result.AppendError("'plugin load' requires one argument");

lldb/trunk/source/Commands/CommandObjectProcess.cpp

CommandObjectProcessLaunch(CommandInterpreter &interpreter)
     arg.push_back(run_args_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectProcessLaunch() override = default;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
 
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
   Options *GetOptions() override { return &m_options; }
 
   const char *GetRepeatCommand(Args &current_command_args,
                                uint32_t index) override {
     // No repeat for "process launch"...
     return "";

lldb/trunk/source/Commands/CommandObjectSettings.cpp

llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_settings_set_options);
     }
 
     // Instance variables to hold the values for command options.
     bool m_global;
     bool m_force;
   };
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
 
     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] != '-')
if (request.GetCursorIndex() == setting_var_idx) {
           lldb::OptionValueSP value_sp(GetDebugger().GetPropertyValue(
               &m_exe_ctx, setting_var_name, false, error));
           if (value_sp) {
             value_sp->AutoComplete(m_interpreter, request);
           }
         }
       }
     }
-    return request.GetNumberOfMatches();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     Args cmd_args(command);
 
     // Process possible options.
CommandObjectSettingsShow(CommandInterpreter &interpreter)
     arg1.push_back(var_name_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg1);
   }
 
   ~CommandObjectSettingsShow() override = default;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishResult);
 
     if (!args.empty()) {
       for (const auto &arg : args) {
CommandObjectSettingsList(CommandInterpreter &interpreter)
     arg.push_back(prefix_name_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectSettingsList() override = default;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishResult);
 
     const bool will_modify = false;
     const size_t argc = args.GetArgumentCount();
CommandObjectSettingsRemove(CommandInterpreter &interpreter)
     m_arguments.push_back(arg1);
     m_arguments.push_back(arg2);
   }
 
   ~CommandObjectSettingsRemove() override = default;
 
   bool WantsCompletion() override { return true; }
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
           request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
     Args cmd_args(command);
public:
   }
 
   ~CommandObjectSettingsReplace() override = default;
 
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     // Attempting to complete variable name
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
           request, nullptr);
-
-    return request.GetNumberOfMatches();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
     Args cmd_args(command);
public:
   }
 
   ~CommandObjectSettingsInsertBefore() override = default;
 
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     // Attempting to complete variable name
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
           request, nullptr);
-
-    return request.GetNumberOfMatches();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
     Args cmd_args(command);
public:
   }
 
   ~CommandObjectSettingsInsertAfter() override = default;
 
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     // Attempting to complete variable name
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
           request, nullptr);
-
-    return request.GetNumberOfMatches();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
     Args cmd_args(command);
public:
   }
 
   ~CommandObjectSettingsAppend() override = default;
 
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     // Attempting to complete variable name
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
           request, nullptr);
-
-    return request.GetNumberOfMatches();
   }
 
 protected:
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     Args cmd_args(command);
     const size_t argc = cmd_args.GetArgumentCount();
CommandObjectSettingsClear(CommandInterpreter &interpreter)
     arg.push_back(var_name_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectSettingsClear() override = default;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     // Attempting to complete variable name
     if (request.GetCursorIndex() < 2)
       CommandCompletions::InvokeCommonCompletionCallbacks(
           GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion,
           request, nullptr);
-
-    return request.GetNumberOfMatches();
   }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     const size_t argc = command.GetArgumentCount();
 
     if (argc != 1) {

lldb/trunk/source/Commands/CommandObjectTarget.cpp

CommandObjectTargetCreate(CommandInterpreter &interpreter)
     m_option_group.Append(&m_add_dependents, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Finalize();
   }
 
   ~CommandObjectTargetCreate() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
 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,
     arg.push_back(file_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectTargetModulesModuleAutoComplete() override = default;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eModuleCompletion, request,
         nullptr);
-    return request.GetNumberOfMatches();
   }
 };
 
 #pragma mark CommandObjectTargetModulesSourceFileAutoComplete
 
 // A base command object class that can auto complete with module source
 // file paths
 
CommandObjectTargetModulesSourceFileAutoComplete(
     arg.push_back(source_file_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectTargetModulesSourceFileAutoComplete() override = default;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eSourceFileCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 };
 
 #pragma mark CommandObjectTargetModulesDumpObjfile
 
 class CommandObjectTargetModulesDumpObjfile
     : public CommandObjectTargetModulesModuleAutoComplete {
 public:
CommandObjectTargetModulesAdd(CommandInterpreter &interpreter)
     m_option_group.Append(&m_symbol_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Finalize();
   }
 
   ~CommandObjectTargetModulesAdd() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
 protected:
   OptionGroupOptions m_option_group;
   OptionGroupUUID m_uuid_option_group;
   OptionGroupFile m_symbol_file;
 
   bool DoExecute(Args &args, CommandReturnObject &result) override {
CommandObjectTargetSymbolsAdd(CommandInterpreter &interpreter)
     m_option_group.Append(&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Append(&m_current_frame_option, LLDB_OPT_SET_2,
                           LLDB_OPT_SET_2);
     m_option_group.Finalize();
   }
 
   ~CommandObjectTargetSymbolsAdd() override = default;
 
-  int HandleArgumentCompletion(
-      CompletionRequest &request,
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
         request, nullptr);
-    return request.GetNumberOfMatches();
   }
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
   bool AddModuleSymbols(Target *target, ModuleSpec &module_spec, bool &flush,
                         CommandReturnObject &result) {
     const FileSpec &symbol_fspec = module_spec.GetSymbolFileSpec();

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(CompletionRequest &request) {
+void FormatEntity::AutoComplete(CompletionRequest &request) {
   llvm::StringRef str = request.GetCursorArgumentPrefix();
 
-  request.SetWordComplete(false);
-
   const size_t dollar_pos = str.rfind('$');
   if (dollar_pos == llvm::StringRef::npos)
-    return 0;
+    return;
 
   // Hitting TAB after $ at the end of the string add a "{"
   if (dollar_pos == str.size() - 1) {
     std::string match = str.str();
     match.append("{");
     request.AddCompletion(match);
-    return 1;
+    return;
   }
 
   if (str[dollar_pos + 1] != '{')
-    return 0;
+    return;
 
   const size_t close_pos = str.find('}', dollar_pos + 2);
   if (close_pos != llvm::StringRef::npos)
-    return 0;
+    return;
 
   const size_t format_pos = str.find('%', dollar_pos + 2);
   if (format_pos != llvm::StringRef::npos)
-    return 0;
+    return;
 
   llvm::StringRef partial_variable(str.substr(dollar_pos + 2));
   if (partial_variable.empty()) {
     // Suggest all top level entites as we are just past "${"
     StringList new_matches;
     AddMatches(&g_root, str, llvm::StringRef(), new_matches);
     request.AddCompletions(new_matches);
-    return request.GetNumberOfMatches();
+    return;
   }
 
   // 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;
+    return;
 
   const size_t n = entry_def->num_children;
 
   if (remainder.empty()) {
     // Exact match
     if (n > 0) {
       // "${thread.info" <TAB>
       request.AddCompletion(MakeMatch(str, "."));
     } else {
       // "${thread.id" <TAB>
       request.AddCompletion(MakeMatch(str, "}"));
-      request.SetWordComplete(true);
     }
   } else if (remainder.equals(".")) {
     // "${thread." <TAB>
     StringList new_matches;
     AddMatches(entry_def, str, llvm::StringRef(), new_matches);
     request.AddCompletions(new_matches);
   } else {
     // We have a partial match
     // "${thre" <TAB>
     StringList new_matches;
     AddMatches(entry_def, str, remainder, new_matches);
     request.AddCompletions(new_matches);
   }
-  return request.GetNumberOfMatches();
 }

lldb/trunk/source/Core/IOHandler.cpp

IOHandlerConfirm::IOHandlerConfirm(Debugger &debugger, llvm::StringRef prompt,
   else
     prompt_stream.Printf(": [y/N] ");
 
   SetPrompt(prompt_stream.GetString());
 }
 
 IOHandlerConfirm::~IOHandlerConfirm() = default;
 
-int IOHandlerConfirm::IOHandlerComplete(IOHandler &io_handler,
+void IOHandlerConfirm::IOHandlerComplete(IOHandler &io_handler,
                                          CompletionRequest &request) {
   if (request.GetRawCursorPos() == 0) {
     if (m_default_response)
       request.AddCompletion("y");
     else
       request.AddCompletion("n");
   }
-  return request.GetNumberOfMatches();
 }
 
 void IOHandlerConfirm::IOHandlerInputComplete(IOHandler &io_handler,
                                               std::string &line) {
   if (line.empty()) {
     // User just hit enter, set the response to the default
     m_user_response = m_default_response;
     io_handler.SetIsDone(true);
if (line == "yes" || line == "YES" || line == "Yes") {
     m_user_response = true;
     io_handler.SetIsDone(true);
   } else if (line == "no" || line == "NO" || line == "No") {
     m_user_response = false;
     io_handler.SetIsDone(true);
   }
 }
 
-int IOHandlerDelegate::IOHandlerComplete(IOHandler &io_handler,
+void IOHandlerDelegate::IOHandlerComplete(IOHandler &io_handler,
                                           CompletionRequest &request) {
   switch (m_completion) {
   case Completion::None:
     break;
-
   case Completion::LLDBCommand:
-    return io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion(
-        request);
-  case Completion::Expression: {
-    CompletionResult result;
-    CompletionRequest subrequest(request.GetRawLine(),
-                                 request.GetRawCursorPos(), result);
+    io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion(request);
+    break;
+  case Completion::Expression:
     CommandCompletions::InvokeCommonCompletionCallbacks(
         io_handler.GetDebugger().GetCommandInterpreter(),
-        CommandCompletions::eVariablePathCompletion, subrequest, nullptr);
-    StringList matches;
-    StringList descriptions;
-    result.GetMatches(matches);
-    result.GetDescriptions(descriptions);
-
-    size_t num_matches = subrequest.GetNumberOfMatches();
-    if (num_matches > 0) {
-      std::string common_prefix = matches.LongestCommonPrefix();
-      const size_t partial_name_len =
-          subrequest.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 && subrequest.GetWordComplete()) {
-        common_prefix.push_back(' ');
-      }
-      common_prefix.erase(0, partial_name_len);
-      request.AddCompletion(common_prefix);
-    }
-    request.AddCompletions(matches, descriptions);
-    return request.GetNumberOfMatches();
-  } break;
+        CommandCompletions::eVariablePathCompletion, request, nullptr);
+    break;
   }
-
-  return 0;
 }
 
 IOHandlerEditline::IOHandlerEditline(
     Debugger &debugger, IOHandler::Type type,
     const char *editline_name, // Used for saving history files
     llvm::StringRef prompt, llvm::StringRef continuation_prompt,
     bool multi_line, bool color_prompts, uint32_t line_number_start,
     IOHandlerDelegate &delegate, repro::DataRecorder *data_recorder)
int IOHandlerEditline::FixIndentationCallback(Editline *editline,
                                               const StringList &lines,
                                               int cursor_position,
                                               void *baton) {
   IOHandlerEditline *editline_reader = (IOHandlerEditline *)baton;
   return editline_reader->m_delegate.IOHandlerFixIndentation(
       *editline_reader, lines, cursor_position);
 }
 
-int IOHandlerEditline::AutoCompleteCallback(CompletionRequest &request,
+void IOHandlerEditline::AutoCompleteCallback(CompletionRequest &request,
                                              void *baton) {
   IOHandlerEditline *editline_reader = (IOHandlerEditline *)baton;
   if (editline_reader)
-    return editline_reader->m_delegate.IOHandlerComplete(*editline_reader,
-                                                         request);
-  return 0;
+    editline_reader->m_delegate.IOHandlerComplete(*editline_reader, request);
 }
 #endif
 
 const char *IOHandlerEditline::GetPrompt() {
 #ifndef LLDB_DISABLE_LIBEDIT
   if (m_editline_up) {
     return m_editline_up->GetPrompt();
   } else {

lldb/trunk/source/Core/PluginManager.cpp

if (name) {
     for (pos = instances.begin(); pos != end; ++pos) {
       if (name == pos->name)
         return pos->create_callback;
     }
   }
   return nullptr;
 }
 
-size_t PluginManager::AutoCompletePlatformName(llvm::StringRef name,
-                                               StringList &matches) {
+void PluginManager::AutoCompletePlatformName(llvm::StringRef name,
+                                             CompletionRequest &request) {
   if (name.empty())
-    return matches.GetSize();
+    return;
 
   std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
   PlatformInstances &instances = GetPlatformInstances();
   llvm::StringRef name_sref(name);
 
   PlatformInstances::iterator pos, end = instances.end();
   for (pos = instances.begin(); pos != end; ++pos) {
     llvm::StringRef plugin_name(pos->name.GetCString());
     if (plugin_name.startswith(name_sref))
-      matches.AppendString(plugin_name.data());
+      request.AddCompletion(plugin_name.data());
   }
-  return matches.GetSize();
 }
 
 #pragma mark Process
 
 struct ProcessInstance {
   ProcessInstance()
       : name(), description(), create_callback(nullptr),
         debugger_init_callback(nullptr) {}

lldb/trunk/source/Expression/REPL.cpp

if (code.empty()) {
     if (!did_quit && (!process_sp || !process_sp->IsAlive())) {
       error_sp->Printf(
           "error: REPL process is no longer alive, exiting REPL\n");
       io_handler.SetIsDone(true);
     }
   }
 }
 
-int REPL::IOHandlerComplete(IOHandler &io_handler, CompletionRequest &request) {
+void REPL::IOHandlerComplete(IOHandler &io_handler,
+                             CompletionRequest &request) {
   // Complete an LLDB command if the first character is a colon...
   if (request.GetRawLine().startswith(":")) {
     Debugger &debugger = m_target.GetDebugger();
 
     // auto complete LLDB commands
     llvm::StringRef new_line = request.GetRawLine().drop_front();
     CompletionResult sub_result;
     CompletionRequest sub_request(new_line, request.GetRawCursorPos() - 1,
                                   sub_result);
-    int result = debugger.GetCommandInterpreter().HandleCompletion(sub_request);
+    debugger.GetCommandInterpreter().HandleCompletion(sub_request);
     StringList matches, descriptions;
     sub_result.GetMatches(matches);
     sub_result.GetDescriptions(descriptions);
     request.AddCompletions(matches, descriptions);
-    return result;
+    return;
   }
 
   // Strip spaces from the line and see if we had only spaces
   if (request.GetRawLineUntilCursor().trim().empty()) {
     // Only spaces on this line, so just indent
     request.AddCompletion(m_indent_str);
-    return 1;
+    return;
   }
 
   std::string current_code;
   current_code.append(m_code.CopyList());
 
   IOHandlerEditline &editline = static_cast<IOHandlerEditline &>(io_handler);
   const StringList *current_lines = editline.GetCurrentLines();
   if (current_lines) {
if (current_lines) {
     }
   }
 
   current_code.append("\n");
   current_code += request.GetRawLineUntilCursor();
 
   StringList matches;
   int result = CompleteCode(current_code, matches);
+  if (result == -2) {
+    assert(matches.GetSize() == 1);
+    request.AddCompletion(matches.GetStringAtIndex(0), "",
+                          CompletionMode::RewriteLine);
+  } else
     request.AddCompletions(matches);
-  return result;
 }
 
 bool QuitCommandOverrideCallback(void *baton, const char **argv) {
   Target *target = (Target *)baton;
   lldb::ProcessSP process_sp(target->GetProcessSP());
   if (process_sp) {
     process_sp->Destroy(false);
     process_sp->GetTarget().GetDebugger().ClearIOHandlers();

lldb/trunk/source/Host/common/Editline.cpp

unsigned char Editline::BufferEndCommand(int ch) {
   MoveCursor(CursorLocation::EditingCursor, CursorLocation::BlockEnd);
   SetCurrentLine((int)m_input_lines.size() - 1);
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
   return CC_NEWLINE;
 }
 
 /// Prints completions and their descriptions to the given file. Only the
 /// completions in the interval [start, end) are printed.
-static void PrintCompletion(FILE *output_file, size_t start, size_t end,
-                            StringList &completions, StringList &descriptions) {
-  // This is an 'int' because of printf.
-  int max_len = 0;
-
-  for (size_t i = start; i < end; i++) {
-    const char *completion_str = completions.GetStringAtIndex(i);
-    max_len = std::max((int)strlen(completion_str), max_len);
-  }
-
-  for (size_t i = start; i < end; i++) {
-    const char *completion_str = completions.GetStringAtIndex(i);
-    const char *description_str = descriptions.GetStringAtIndex(i);
-
-    if (completion_str)
-      fprintf(output_file, "\n\t%-*s", max_len, completion_str);
-
-    // Print the description if we got one.
-    if (description_str && strlen(description_str))
-      fprintf(output_file, " -- %s", description_str);
+static void
+PrintCompletion(FILE *output_file,
+                llvm::ArrayRef<CompletionResult::Completion> results,
+                size_t max_len) {
+  for (const CompletionResult::Completion &c : results) {
+    fprintf(output_file, "\t%-*s", (int)max_len, c.GetCompletion().c_str());
+    if (!c.GetDescription().empty())
+      fprintf(output_file, " -- %s", c.GetDescription().c_str());
+    fprintf(output_file, "\n");
+  }
+}
+
+static void
+DisplayCompletions(::EditLine *editline, FILE *output_file,
+                   llvm::ArrayRef<CompletionResult::Completion> results) {
+  assert(!results.empty());
+
+  fprintf(output_file, "\n" ANSI_CLEAR_BELOW "Available completions:\n");
+  const size_t page_size = 40;
+  bool all = false;
+
+  auto longest =
+      std::max_element(results.begin(), results.end(), [](auto &c1, auto &c2) {
+        return c1.GetCompletion().size() < c2.GetCompletion().size();
+      });
+
+  const size_t max_len = longest->GetCompletion().size();
+
+  if (results.size() < page_size) {
+    PrintCompletion(output_file, results, max_len);
+    return;
+  }
+
+  size_t cur_pos = 0;
+  while (cur_pos < results.size()) {
+    size_t remaining = results.size() - cur_pos;
+    size_t next_size = all ? remaining : std::min(page_size, remaining);
+
+    PrintCompletion(output_file, results.slice(cur_pos, next_size), max_len);
+
+    cur_pos += next_size;
+
+    if (cur_pos >= results.size())
+      break;
+
+    fprintf(output_file, "More (Y/n/a): ");
+    char reply = 'n';
+    int got_char = el_getc(editline, &reply);
+    fprintf(output_file, "\n");
+    if (got_char == -1 || reply == 'n')
+      break;
+    if (reply == 'a')
+      all = true;
   }
 }
 
 unsigned char Editline::TabCommand(int ch) {
   if (m_completion_callback == nullptr)
     return CC_ERROR;
 
   const LineInfo *line_info = el_line(m_editline);
-  StringList completions, descriptions;
-  int page_size = 40;
 
   llvm::StringRef line(line_info->buffer,
                        line_info->lastchar - line_info->buffer);
   unsigned cursor_index = line_info->cursor - line_info->buffer;
   CompletionResult result;
   CompletionRequest request(line, cursor_index, result);
 
-  const int num_completions =
-      m_completion_callback(request, m_completion_callback_baton);
 
+  llvm::ArrayRef<CompletionResult::Completion> results = result.GetResults();
+
+  StringList completions;
   result.GetMatches(completions);
-  result.GetDescriptions(descriptions);
 
-  if (num_completions == 0)
+  if (results.size() == 0)
     return CC_ERROR;
-  //    if (num_completions == -1)
-  //    {
-  //        el_insertstr (m_editline, m_completion_key);
-  //        return CC_REDISPLAY;
-  //    }
-  //    else
-  if (num_completions == -2) {
-    // Replace the entire line with the first string...
+
+  if (results.size() == 1) {
+    CompletionResult::Completion completion = results.front();
+    switch (completion.GetMode()) {
+    case CompletionMode::Normal: {
+      std::string to_add = completion.GetCompletion();
+      to_add = to_add.substr(request.GetCursorArgumentPrefix().size());
+      if (request.GetParsedArg().IsQuoted())
+        to_add.push_back(request.GetParsedArg().quote);
+      to_add.push_back(' ');
+      el_insertstr(m_editline, to_add.c_str());
+      break;
+    }
+    case CompletionMode::RewriteLine: {
       el_deletestr(m_editline, line_info->cursor - line_info->buffer);
-    el_insertstr(m_editline, completions.GetStringAtIndex(0));
+      el_insertstr(m_editline, completion.GetCompletion().c_str());
+      break;
+    }
+    }
     return CC_REDISPLAY;
   }
 
   // If we get a longer match display that first.
-  const char *completion_str = completions.GetStringAtIndex(0);
-  if (completion_str != nullptr && *completion_str != '\0') {
-    el_insertstr(m_editline, completion_str);
+  std::string longest_prefix = completions.LongestCommonPrefix();
+  if (!longest_prefix.empty())
+    longest_prefix =
+        longest_prefix.substr(request.GetCursorArgumentPrefix().size());
+  if (!longest_prefix.empty()) {
+    el_insertstr(m_editline, longest_prefix.c_str());
     return CC_REDISPLAY;
   }
 
-  if (num_completions > 1) {
-    int num_elements = num_completions + 1;
-    fprintf(m_output_file, "\n" ANSI_CLEAR_BELOW "Available completions:");
-    if (num_completions < page_size) {
-      PrintCompletion(m_output_file, 1, num_elements, completions,
-                      descriptions);
-      fprintf(m_output_file, "\n");
-    } else {
-      int cur_pos = 1;
-      char reply;
-      int got_char;
-      while (cur_pos < num_elements) {
-        int endpoint = cur_pos + page_size;
-        if (endpoint > num_elements)
-          endpoint = num_elements;
-
-        PrintCompletion(m_output_file, cur_pos, endpoint, completions,
-                        descriptions);
-        cur_pos = endpoint;
-
-        if (cur_pos >= num_elements) {
-          fprintf(m_output_file, "\n");
-          break;
-        }
+  DisplayCompletions(m_editline, m_output_file, results);
 
-        fprintf(m_output_file, "\nMore (Y/n/a): ");
-        reply = 'n';
-        got_char = el_getc(m_editline, &reply);
-        if (got_char == -1 || reply == 'n')
-          break;
-        if (reply == 'a')
-          page_size = num_elements - cur_pos;
-      }
-    }
-    DisplayInput();
-    MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingCursor);
-  }
   return CC_REDISPLAY;
 }
 
 void Editline::ConfigureEditor(bool multiline) {
   if (m_editline && m_multiline_enabled == multiline)
     return;
   m_multiline_enabled = multiline;
 

lldb/trunk/source/Interpreter/CommandAlias.cpp

 }
 
 bool CommandAlias::WantsCompletion() {
   if (IsValid())
     return m_underlying_command_sp->WantsCompletion();
   return false;
 }
 
-int CommandAlias::HandleCompletion(CompletionRequest &request) {
+void CommandAlias::HandleCompletion(CompletionRequest &request) {
   if (IsValid())
-    return m_underlying_command_sp->HandleCompletion(request);
-  return -1;
+    m_underlying_command_sp->HandleCompletion(request);
 }
 
-int CommandAlias::HandleArgumentCompletion(
+void CommandAlias::HandleArgumentCompletion(
     CompletionRequest &request, OptionElementVector &opt_element_vector) {
   if (IsValid())
-    return m_underlying_command_sp->HandleArgumentCompletion(
-        request, opt_element_vector);
-  return -1;
+    m_underlying_command_sp->HandleArgumentCompletion(request,
+                                                      opt_element_vector);
 }
 
 Options *CommandAlias::GetOptions() {
   if (IsValid())
     return m_underlying_command_sp->GetOptions();
   return nullptr;
 }
 

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

bool CommandInterpreter::HandleCommand(const char *command_line,
   }
 
   LLDB_LOGF(log, "HandleCommand, command %s",
             (result.Succeeded() ? "succeeded" : "did not succeed"));
 
   return result.Succeeded();
 }
 
-int CommandInterpreter::HandleCompletionMatches(CompletionRequest &request) {
-  int num_command_matches = 0;
+void CommandInterpreter::HandleCompletionMatches(CompletionRequest &request) {
   bool look_for_subcommand = false;
 
   // For any of the command completions a unique match will be a complete word.
-  request.SetWordComplete(true);
 
   if (request.GetCursorIndex() == -1) {
     // We got nothing on the command line, so return the list of commands
     bool include_aliases = true;
     StringList new_matches, descriptions;
-    num_command_matches = GetCommandNamesMatchingPartialString(
-        "", include_aliases, new_matches, descriptions);
+    GetCommandNamesMatchingPartialString("", include_aliases, new_matches,
+                                         descriptions);
     request.AddCompletions(new_matches, descriptions);
   } else if (request.GetCursorIndex() == 0) {
     // The cursor is in the first argument, so just do a lookup in the
     // dictionary.
     StringList new_matches, new_descriptions;
     CommandObject *cmd_obj =
         GetCommandObject(request.GetParsedLine().GetArgumentAtIndex(0),
                          &new_matches, &new_descriptions);
 
-    if (num_command_matches == 1 && cmd_obj && cmd_obj->IsMultiwordObject() &&
+    if (new_matches.GetSize() && cmd_obj && cmd_obj->IsMultiwordObject() &&
         new_matches.GetStringAtIndex(0) != nullptr &&
         strcmp(request.GetParsedLine().GetArgumentAtIndex(0),
                new_matches.GetStringAtIndex(0)) == 0) {
-      if (request.GetParsedLine().GetArgumentCount() == 1) {
-        request.SetWordComplete(true);
-      } else {
+      if (request.GetParsedLine().GetArgumentCount() != 1) {
         look_for_subcommand = true;
-        num_command_matches = 0;
         new_matches.DeleteStringAtIndex(0);
         new_descriptions.DeleteStringAtIndex(0);
         request.GetParsedLine().AppendArgument(llvm::StringRef());
         request.SetCursorIndex(request.GetCursorIndex() + 1);
         request.SetCursorCharPosition(0);
       }
     }
     request.AddCompletions(new_matches, new_descriptions);
-    num_command_matches = request.GetNumberOfMatches();
   }
 
   if (request.GetCursorIndex() > 0 || look_for_subcommand) {
     // We are completing further on into a commands arguments, so find the
     // command and tell it to complete the command. First see if there is a
     // matching initial command:
     CommandObject *command_object =
         GetCommandObject(request.GetParsedLine().GetArgumentAtIndex(0));
-    if (command_object == nullptr) {
-      return 0;
-    } else {
+    if (command_object) {
       request.GetParsedLine().Shift();
       request.SetCursorIndex(request.GetCursorIndex() - 1);
-      num_command_matches = command_object->HandleCompletion(request);
+      command_object->HandleCompletion(request);
     }
   }
-
-  return num_command_matches;
 }
 
-int CommandInterpreter::HandleCompletion(CompletionRequest &orig_request) {
-  // Start a new subrequest we can modify.
-  CompletionResult result;
-  CompletionRequest request(orig_request.GetRawLine(),
-                            orig_request.GetRawCursorPos(), result);
+void CommandInterpreter::HandleCompletion(CompletionRequest &request) {
+
   // 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 = request.GetParsedLine().GetArgumentAtIndex(0);
-  StringList matches, descriptions;
+  llvm::StringRef 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.InsertStringAtIndex(0, *hist_str);
-        descriptions.InsertStringAtIndex(0, "Previous command history event");
-        return -2;
-      } else
-        return 0;
+  if (!first_arg.empty()) {
+    if (first_arg.front() == m_comment_char)
+      return;
+    if (first_arg.front() == CommandHistory::g_repeat_char) {
+      if (auto hist_str = m_command_history.FindString(first_arg))
+        request.AddCompletion(*hist_str, "Previous command history event",
+                              CompletionMode::RewriteLine);
+      return;
     }
   }
 
-  int num_command_matches = HandleCompletionMatches(request);
-  result.GetMatches(matches);
-  result.GetDescriptions(descriptions);
-
-  if (num_command_matches <= 0)
-    return num_command_matches;
-
-  if (request.GetParsedLine().GetArgumentCount() == 0) {
-    // If we got an empty string, insert nothing.
-    matches.InsertStringAtIndex(0, "");
-    descriptions.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 = request.GetCursorArgumentPrefix().str();
-
-    std::string common_prefix = matches.LongestCommonPrefix();
-    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 && 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());
-    descriptions.InsertStringAtIndex(0, "");
-  }
-  // Add completion to original request.
-  orig_request.AddCompletions(matches, descriptions);
-  return num_command_matches;
+  HandleCompletionMatches(request);
 }
 
 CommandInterpreter::~CommandInterpreter() {}
 
 void CommandInterpreter::UpdatePrompt(llvm::StringRef new_prompt) {
   EventSP prompt_change_event_sp(
       new Event(eBroadcastBitResetPrompt, new EventDataBytes(new_prompt)));
   ;

lldb/trunk/source/Interpreter/CommandObject.cpp

 }
 
 void CommandObject::Cleanup() {
   m_exe_ctx.Clear();
   if (m_api_locker.owns_lock())
     m_api_locker.unlock();
 }
 
-int CommandObject::HandleCompletion(CompletionRequest &request) {
+void CommandObject::HandleCompletion(CompletionRequest &request) {
   // Default implementation of WantsCompletion() is !WantsRawCommandString().
   // Subclasses who want raw command string but desire, for example, argument
   // completion should override WantsCompletion() to return true, instead.
   if (WantsRawCommandString() && !WantsCompletion()) {
     // FIXME: Abstract telling the completion to insert the completion
     // character.
-    return -1;
+    return;
   } else {
     // Can we do anything generic with the options?
     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 = cur_options->HandleOptionCompletion(
           request, opt_element_vector, GetCommandInterpreter());
       if (handled_by_options)
-        return request.GetNumberOfMatches();
+        return;
     }
 
     // If we got here, the last word is not an option or an option argument.
-    return HandleArgumentCompletion(request, opt_element_vector);
+    HandleArgumentCompletion(request, opt_element_vector);
   }
 }
 
 bool CommandObject::HelpTextContainsWord(llvm::StringRef search_word,
                                          bool search_short_help,
                                          bool search_long_help,
                                          bool search_syntax,
                                          bool search_options) {

lldb/trunk/source/Interpreter/CommandObjectRegexCommand.cpp

if (m_entries.back().regex.IsValid()) {
     m_entries.back().command.assign(command_cstr);
     return true;
   }
   // The regex didn't compile...
   m_entries.pop_back();
   return false;
 }
 
-int CommandObjectRegexCommand::HandleCompletion(CompletionRequest &request) {
+void CommandObjectRegexCommand::HandleCompletion(CompletionRequest &request) {
   if (m_completion_type_mask) {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), m_completion_type_mask, request, nullptr);
-    return request.GetNumberOfMatches();
-  } else {
-    request.SetWordComplete(false);
   }
-  return 0;
 }

lldb/trunk/source/Interpreter/OptionValue.cpp

if (dumped_something)
       strm.PutChar('.');
     else
       dumped_something = true;
     strm << name;
   }
   return dumped_something;
 }
 
-size_t OptionValue::AutoComplete(CommandInterpreter &interpreter,
-                                 CompletionRequest &request) {
-  request.SetWordComplete(false);
-  return request.GetNumberOfMatches();
-}
+void OptionValue::AutoComplete(CommandInterpreter &interpreter,
+                               CompletionRequest &request) {}
 
 Status OptionValue::SetValueFromString(llvm::StringRef value,
                                        VarSetOperationType op) {
   Status error;
   switch (op) {
   case eVarSetOperationReplace:
     error.SetErrorStringWithFormat(
         "%s objects do not support the 'replace' operation",

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,
-                                     CompletionRequest &request) {
-  request.SetWordComplete(false);
+void OptionValueArch::AutoComplete(CommandInterpreter &interpreter,
   CommandCompletions::InvokeCommonCompletionCallbacks(
       interpreter, CommandCompletions::eArchitectureCompletion, request,
       nullptr);
-  return request.GetNumberOfMatches();
 }

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,
-                                        CompletionRequest &request) {
-  request.SetWordComplete(false);
+void OptionValueBoolean::AutoComplete(CommandInterpreter &interpreter,
   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 (request.GetCursorArgumentPrefix().empty())
     entries = entries.take_front(2);
 
   for (auto entry : entries) {
     if (entry.startswith_lower(request.GetCursorArgumentPrefix()))
       request.AddCompletion(entry);
   }
-  return request.GetNumberOfMatches();
 }

lldb/trunk/source/Interpreter/OptionValueEnumeration.cpp

void OptionValueEnumeration::SetEnumerations(
 
   m_enumerations.Sort();
 }
 
 lldb::OptionValueSP OptionValueEnumeration::DeepCopy() const {
   return OptionValueSP(new OptionValueEnumeration(*this));
 }
 
-size_t OptionValueEnumeration::AutoComplete(CommandInterpreter &interpreter,
-                                            CompletionRequest &request) {
-  request.SetWordComplete(false);
-
+void OptionValueEnumeration::AutoComplete(CommandInterpreter &interpreter,
   const uint32_t num_enumerators = m_enumerations.GetSize();
   if (!request.GetCursorArgumentPrefix().empty()) {
     for (size_t i = 0; i < num_enumerators; ++i) {
       llvm::StringRef name = m_enumerations.GetCStringAtIndex(i).GetStringRef();
       if (name.startswith(request.GetCursorArgumentPrefix()))
         request.AddCompletion(name);
     }
   } else {
     // only suggest "true" or "false" by default
     for (size_t i = 0; i < num_enumerators; ++i)
       request.AddCompletion(m_enumerations.GetCStringAtIndex(i).GetStringRef());
   }
-  return request.GetNumberOfMatches();
 }

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,
-                                         CompletionRequest &request) {
-  request.SetWordComplete(false);
+void OptionValueFileSpec::AutoComplete(CommandInterpreter &interpreter,
   CommandCompletions::InvokeCommonCompletionCallbacks(
       interpreter, m_completion_mask, request, nullptr);
-  return request.GetNumberOfMatches();
 }
 
 const lldb::DataBufferSP &OptionValueFileSpec::GetFileContents() {
   if (m_current_value) {
     const auto file_mod_time = FileSystem::Instance().GetModificationTime(m_current_value);
     if (m_data_sp && m_data_mod_time == file_mod_time)
       return m_data_sp;
     m_data_sp =
         FileSystem::Instance().CreateDataBuffer(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,
-                                             CompletionRequest &request) {
-  return FormatEntity::AutoComplete(request);
+void OptionValueFormatEntity::AutoComplete(CommandInterpreter &interpreter,
+  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,
-                                     CompletionRequest &request) {
-  request.SetWordComplete(false);
+void OptionValueUUID::AutoComplete(CommandInterpreter &interpreter,
   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(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)) {
               request.AddCompletion(module_uuid.GetAsString());
             }
           }
         }
       }
     }
   }
-  return request.GetNumberOfMatches();
 }

lldb/trunk/source/Interpreter/Options.cpp

bool Options::VerifyPartialOptions(CommandReturnObject &result) {
   }
 
   return options_are_valid;
 }
 
 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 = request.GetCursorArgumentPrefix().str();
if (opt_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(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.

lldb/trunk/source/Symbol/Variable.cpp

if (compiler_type.IsValid()) {
       case eTypeClassComplexInteger:
       case eTypeClassEnumeration:
       case eTypeClassFunction:
       case eTypeClassMemberPointer:
       case eTypeClassReference:
       case eTypeClassTypedef:
       case eTypeClassVector: {
         request.AddCompletion(prefix_path.str());
-        request.SetWordComplete(true);
       } break;
 
       case eTypeClassClass:
       case eTypeClassStruct:
       case eTypeClassUnion:
         if (prefix_path.str().back() != '.')
           request.AddCompletion((prefix_path + ".").str());
         break;
 
       case eTypeClassObjCObject:
       case eTypeClassObjCInterface:
         break;
       case eTypeClassObjCObjectPointer:
       case eTypeClassPointer: {
         bool omit_empty_base_classes = true;
         if (compiler_type.GetNumChildren(omit_empty_base_classes, nullptr) > 0)
           request.AddCompletion((prefix_path + "->").str());
         else {
           request.AddCompletion(prefix_path.str());
-          request.SetWordComplete(true);
         }
       } break;
       }
     } else {
       if (frame) {
         const bool get_file_globals = true;
 
         VariableList *variable_list = frame->GetVariableList(get_file_globals);
default:
           }
         }
       }
       break;
     }
   }
 }
 
-size_t Variable::AutoComplete(const ExecutionContext &exe_ctx,
-                              CompletionRequest &request) {
+void Variable::AutoComplete(const ExecutionContext &exe_ctx,
   CompilerType compiler_type;
 
   PrivateAutoComplete(exe_ctx.GetFramePtr(), request.GetCursorArgumentPrefix(),
                       "", compiler_type, request);
-
-  return request.GetNumberOfMatches();
 }

lldb/trunk/source/Utility/ArchSpec.cpp

struct ArchDefinition {
   const char *name;
 };
 
 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) {
+void 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,
                       request.GetCursorArgumentPrefix()))
         request.AddCompletion(g_core_definitions[i].name);
     }
   } else {
     StringList matches;
     ListSupportedArchNames(matches);
     request.AddCompletions(matches);
   }
-  return request.GetNumberOfMatches();
 }
 
 #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

std::string CompletionResult::Completion::GetUniqueKey() const {
   // prefix the key with the length of the completion string. This prevents
   // that we could get any collisions from completions pairs such as these:
   // "foo:", "bar" would be "foo:bar", but will now be: "4foo:bar"
   // "foo", ":bar" would be "foo:bar", but will now be: "3foo:bar"
 
   std::string result;
   result.append(std::to_string(m_completion.size()));
   result.append(m_completion);
+  result.append(std::to_string(static_cast<int>(m_mode)));
+  result.append(":");
   result.append(m_descripton);
   return result;
 }
 
 void CompletionResult::AddResult(llvm::StringRef completion,
-                                 llvm::StringRef description) {
-  Completion r(completion, description);
+                                 llvm::StringRef description,
+                                 CompletionMode mode) {
+  Completion r(completion, description, mode);
 
   // Add the completion if we haven't seen the same value before.
   if (m_added_values.insert(r.GetUniqueKey()).second)
     m_results.push_back(r);
 }
 
 void CompletionResult::GetMatches(StringList &matches) const {
   matches.Clear();
   for (const Completion &completion : m_results)
-    matches.AppendString(completion.m_completion);
+    matches.AppendString(completion.GetCompletion());
 }
 
 void CompletionResult::GetDescriptions(StringList &descriptions) const {
   descriptions.Clear();
   for (const Completion &completion : m_results)
-    descriptions.AppendString(completion.m_descripton);
+    descriptions.AppendString(completion.GetDescription());
 }

lldb/trunk/unittests/Interpreter/TestCompletion.cpp

static bool HasEquivalentFile(const Twine &Path, const StringList &Paths) {
     return false;
   }
 
   void DoDirCompletions(const Twine &Prefix,
                         StandardTildeExpressionResolver &Resolver,
                         StringList &Results) {
     // When a partial name matches, it returns all matches.  If it matches both
     // a full name AND some partial names, it returns all of them.
-    uint32_t Count =
-        CommandCompletions::DiskDirectories(Prefix + "foo", Results, Resolver);
-    ASSERT_EQ(4u, Count);
-    ASSERT_EQ(Count, Results.GetSize());
+    ASSERT_EQ(4u, Results.GetSize());
     EXPECT_TRUE(HasEquivalentFile(DirFoo, Results));
     EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
     EXPECT_TRUE(HasEquivalentFile(DirFooB, Results));
     EXPECT_TRUE(HasEquivalentFile(DirFooC, Results));
 
     // If it matches only partial names, it still works as expected.
-    Count = CommandCompletions::DiskDirectories(Twine(Prefix) + "b", Results,
-                                                Resolver);
-    ASSERT_EQ(2u, Count);
-    ASSERT_EQ(Count, Results.GetSize());
+    CommandCompletions::DiskDirectories(Twine(Prefix) + "b", Results, Resolver);
+    ASSERT_EQ(2u, Results.GetSize());
     EXPECT_TRUE(HasEquivalentFile(DirBar, Results));
     EXPECT_TRUE(HasEquivalentFile(DirBaz, Results));
   }
 };
 
 SmallString<128> CompletionTest::OriginalWorkingDir;
 } // namespace
 
TEST_F(CompletionTest, DirCompletionAbsolute) {
   std::string Prefixes[] = {(Twine(BaseDir) + "/").str(), ""};
 
   StandardTildeExpressionResolver Resolver;
   StringList Results;
 
   // When a directory is specified that doesn't end in a slash, it searches
   // for that directory, not items under it.
   // Sanity check that the path we complete on exists and isn't too long.
-  size_t Count = CommandCompletions::DiskDirectories(Twine(BaseDir) + "/fooa",
-                                                     Results, Resolver);
-  ASSERT_EQ(1u, Count);
-  ASSERT_EQ(Count, Results.GetSize());
+  CommandCompletions::DiskDirectories(Twine(BaseDir) + "/fooa", Results,
+                                      Resolver);
+  ASSERT_EQ(1u, Results.GetSize());
   EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
 
-  Count = CommandCompletions::DiskDirectories(Twine(BaseDir) + "/.", Results,
-                                              Resolver);
-  ASSERT_EQ(0u, Count);
-  ASSERT_EQ(Count, Results.GetSize());
+  CommandCompletions::DiskDirectories(Twine(BaseDir) + "/.", Results, Resolver);
+  ASSERT_EQ(0u, Results.GetSize());
 
   // When the same directory ends with a slash, it finds all children.
-  Count = CommandCompletions::DiskDirectories(Prefixes[0], Results, Resolver);
-  ASSERT_EQ(7u, Count);
-  ASSERT_EQ(Count, Results.GetSize());
+  CommandCompletions::DiskDirectories(Prefixes[0], Results, Resolver);
+  ASSERT_EQ(7u, Results.GetSize());
   EXPECT_TRUE(HasEquivalentFile(DirFoo, Results));
   EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
   EXPECT_TRUE(HasEquivalentFile(DirFooB, Results));
   EXPECT_TRUE(HasEquivalentFile(DirFooC, Results));
   EXPECT_TRUE(HasEquivalentFile(DirBar, Results));
   EXPECT_TRUE(HasEquivalentFile(DirBaz, Results));
   EXPECT_TRUE(HasEquivalentFile(DirTestFolder, Results));
 
   DoDirCompletions(Twine(BaseDir) + "/", Resolver, Results);
   llvm::sys::fs::set_current_path(BaseDir);
   DoDirCompletions("", Resolver, Results);
 }
 
 TEST_F(CompletionTest, FileCompletionAbsolute) {
   // All calls to DiskFiles() return both files and directories  The tests below
   // all check this by asserting an exact result count, and verifying against
   // known folders.
 
   StandardTildeExpressionResolver Resolver;
   StringList Results;
   // When an item is specified that doesn't end in a slash but exactly matches
   // one item, it returns that item.
-  size_t Count = CommandCompletions::DiskFiles(Twine(BaseDir) + "/fooa",
-                                               Results, Resolver);
-  ASSERT_EQ(1u, Count);
-  ASSERT_EQ(Count, Results.GetSize());
+  CommandCompletions::DiskFiles(Twine(BaseDir) + "/fooa", Results, Resolver);
+  ASSERT_EQ(1u, Results.GetSize());
   EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
 
   // The previous check verified a directory match.  But it should work for
   // files too.
-  Count =
-      CommandCompletions::DiskFiles(Twine(BaseDir) + "/aa", Results, Resolver);
-  ASSERT_EQ(1u, Count);
-  ASSERT_EQ(Count, Results.GetSize());
+  ASSERT_EQ(1u, Results.GetSize());
   EXPECT_TRUE(HasEquivalentFile(FileAA, Results));
 
   // When it ends with a slash, it should find all files and directories.
-  Count =
-      CommandCompletions::DiskFiles(Twine(BaseDir) + "/", Results, Resolver);
-  ASSERT_EQ(13u, Count);
-  ASSERT_EQ(Count, Results.GetSize());
+  ASSERT_EQ(13u, Results.GetSize());
   EXPECT_TRUE(HasEquivalentFile(DirFoo, Results));
   EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
   EXPECT_TRUE(HasEquivalentFile(DirFooB, Results));
   EXPECT_TRUE(HasEquivalentFile(DirFooC, Results));
   EXPECT_TRUE(HasEquivalentFile(DirBar, Results));
   EXPECT_TRUE(HasEquivalentFile(DirBaz, Results));
   EXPECT_TRUE(HasEquivalentFile(DirTestFolder, Results));
 
   EXPECT_TRUE(HasEquivalentFile(FileAA, Results));
   EXPECT_TRUE(HasEquivalentFile(FileAB, Results));
   EXPECT_TRUE(HasEquivalentFile(FileAC, Results));
   EXPECT_TRUE(HasEquivalentFile(FileFoo, Results));
   EXPECT_TRUE(HasEquivalentFile(FileBar, Results));
   EXPECT_TRUE(HasEquivalentFile(FileBaz, Results));
 
   // When a partial name matches, it returns all file & directory matches.
-  Count =
-      CommandCompletions::DiskFiles(Twine(BaseDir) + "/foo", Results, Resolver);
-  ASSERT_EQ(5u, Count);
-  ASSERT_EQ(Count, Results.GetSize());
+  ASSERT_EQ(5u, Results.GetSize());
   EXPECT_TRUE(HasEquivalentFile(DirFoo, Results));
   EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
   EXPECT_TRUE(HasEquivalentFile(DirFooB, Results));
   EXPECT_TRUE(HasEquivalentFile(DirFooC, Results));
   EXPECT_TRUE(HasEquivalentFile(FileFoo, Results));
 }
 
 TEST_F(CompletionTest, DirCompletionUsername) {
   MockTildeExpressionResolver Resolver("James", BaseDir);
   Resolver.AddKnownUser("Kirk", DirFooB);
   Resolver.AddKnownUser("Lars", DirFooC);
   Resolver.AddKnownUser("Jason", DirFoo);
   Resolver.AddKnownUser("Larry", DirFooA);
   std::string sep = path::get_separator();
 
   // Just resolving current user's home directory by itself should return the
   // directory.
   StringList Results;
-  size_t Count = CommandCompletions::DiskDirectories("~", Results, Resolver);
-  EXPECT_EQ(Count, Results.GetSize());
+  CommandCompletions::DiskDirectories("~", Results, Resolver);
   EXPECT_THAT(toVector(Results), UnorderedElementsAre("~" + sep));
 
   // With a slash appended, it should return all items in the directory.
-  Count = CommandCompletions::DiskDirectories("~/", Results, Resolver);
+  CommandCompletions::DiskDirectories("~/", Results, Resolver);
   EXPECT_THAT(toVector(Results),
               UnorderedElementsAre(
                   "~/foo" + sep, "~/fooa" + sep, "~/foob" + sep, "~/fooc" + sep,
                   "~/bar" + sep, "~/baz" + sep, "~/test_folder" + sep));
-  EXPECT_EQ(Count, Results.GetSize());
 
   // Check that we can complete directories in nested paths
-  Count = CommandCompletions::DiskDirectories("~/foo/", Results, Resolver);
-  EXPECT_EQ(Count, Results.GetSize());
+  CommandCompletions::DiskDirectories("~/foo/", Results, Resolver);
   EXPECT_THAT(toVector(Results), UnorderedElementsAre("~/foo/nested" + sep));
 
-  Count = CommandCompletions::DiskDirectories("~/foo/nes", Results, Resolver);
-  EXPECT_EQ(Count, Results.GetSize());
+  CommandCompletions::DiskDirectories("~/foo/nes", Results, Resolver);
   EXPECT_THAT(toVector(Results), UnorderedElementsAre("~/foo/nested" + sep));
 
   // With ~username syntax it should return one match if there is an exact
   // match.  It shouldn't translate to the actual directory, it should keep the
   // form the user typed.
-  Count = CommandCompletions::DiskDirectories("~Lars", Results, Resolver);
-  EXPECT_EQ(Count, Results.GetSize());
+  CommandCompletions::DiskDirectories("~Lars", Results, Resolver);
   EXPECT_THAT(toVector(Results), UnorderedElementsAre("~Lars" + sep));
 
   // But with a username that is not found, no results are returned.
-  Count = CommandCompletions::DiskDirectories("~Dave", Results, Resolver);
-  EXPECT_EQ(Count, Results.GetSize());
+  CommandCompletions::DiskDirectories("~Dave", Results, Resolver);
   EXPECT_THAT(toVector(Results), UnorderedElementsAre());
 
   // And if there are multiple matches, it should return all of them.
-  Count = CommandCompletions::DiskDirectories("~La", Results, Resolver);
-  EXPECT_EQ(Count, Results.GetSize());
+  CommandCompletions::DiskDirectories("~La", Results, Resolver);
   EXPECT_THAT(toVector(Results),
               UnorderedElementsAre("~Lars" + sep, "~Larry" + sep));
 }

lldb/trunk/unittests/Utility/CompletionRequestTest.cpp

TEST(CompletionRequest, Constructor) {
 
   CompletionRequest request(command, cursor_pos, result);
   result.GetMatches(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.GetWordComplete(), false);
 
   EXPECT_EQ(request.GetPartialParsedLine().GetArgumentCount(), 2u);
   EXPECT_STREQ(request.GetPartialParsedLine().GetArgumentAtIndex(1), "b");
 }
 
 TEST(CompletionRequest, DuplicateFiltering) {
   std::string command = "a bad c";
   const unsigned cursor_pos = 3;