Make AutoComplete code use StringRef

[zturner]

Summary

As per the title. beanz@, could you specifically look over my usage of llvm::Twine? This is the first time I've used this class, and I'm not sure if I'm using it correctly / efficiently.

[tfiala]

I can give this one a run though on macOS in the morning.

[tfiala]

I'm going to test this one now, stacked on top of the final macOS-working version of D26698. Tell me now if you want it tested independently of D26698.

[beanz]

LGTM!

The big thing to be aware of about Twines is that they are designed so that when you construct one the underlying string storage can vanish after the Twine goes out of scope. Here it looks like you're really just allowing some functions to take Twines, it doesn't look like you're constructing any, so it seems all good to me.

[tfiala]

LGTM! All tests passed on macOS 10.12.2 public beta with Xcode 8.1.

lldb/trunk/include/lldb/Core/ArchSpec.h

public:
   /// Assignment operator.
   ///
   /// @param[in] rhs another ArchSpec object to copy.
   ///
   /// @return A const reference to this object.
   //------------------------------------------------------------------
   const ArchSpec &operator=(const ArchSpec &rhs);
 
-  static size_t AutoComplete(const char *name, StringList &matches);
+  static size_t AutoComplete(llvm::StringRef name, StringList &matches);
 
   //------------------------------------------------------------------
   /// Returns a static string representing the current architecture.
   ///
   /// @return A static string correcponding to the current
   ///         architecture.
   //------------------------------------------------------------------
   const char *GetArchitectureName() const;

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

static bool FormatCString(const char *format, Stream &s,
                             bool function_changed, bool initial_function);
 
   static Error Parse(const llvm::StringRef &format, Entry &entry);
 
   static Error ExtractVariableInfo(llvm::StringRef &format_str,
                                    llvm::StringRef &variable_name,
                                    llvm::StringRef &variable_format);
 
-  static size_t AutoComplete(const char *s, int match_start_point,
+  static size_t AutoComplete(llvm::StringRef s, int match_start_point,
                              int max_return_elements, bool &word_complete,
                              StringList &matches);
 
   //----------------------------------------------------------------------
   // 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),

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

public:
 
   static PlatformCreateInstance
   GetPlatformCreateCallbackForPluginName(const ConstString &name);
 
   static const char *GetPlatformPluginNameAtIndex(uint32_t idx);
 
   static const char *GetPlatformPluginDescriptionAtIndex(uint32_t idx);
 
-  static size_t AutoCompletePlatformName(const char *partial_name,
+  static size_t AutoCompletePlatformName(llvm::StringRef partial_name,
                                          StringList &matches);
   //------------------------------------------------------------------
   // Process
   //------------------------------------------------------------------
   static bool
   RegisterPlugin(const ConstString &name, const char *description,
                  ProcessCreateInstance create_callback,
                  DebuggerInitializeCallback debugger_init_callback = nullptr);

lldb/trunk/include/lldb/Core/StringList.h

public:
 
   // This string list contains a list of valid auto completion
   // strings, and the "s" is passed in. "matches" is filled in
   // with zero or more string values that start with "s", and
   // the first string to exactly match one of the string
   // values in this collection, will have "exact_matches_idx"
   // filled in to match the index, or "exact_matches_idx" will
   // have SIZE_MAX
-  size_t AutoComplete(const char *s, StringList &matches,
+  size_t AutoComplete(llvm::StringRef s, StringList &matches,
                       size_t &exact_matches_idx) const;
 
   // Dump the StringList to the given lldb_private::Log, `log`, one item per
   // line.
   // If given, `name` will be used to identify the start and end of the list in
   // the output.
   virtual void LogDump(Log *log, const char *name = nullptr);
 

lldb/trunk/include/lldb/Core/UUID.h

public:
   ///     A NULL terminate C string that points at a UUID string value
   ///     (no leading spaces). The string must contain only hex
   ///     characters and optionally can contain the '-' sepearators.
   ///
   /// @param[in] uuid_bytes
   ///     A buffer of bytes that will contain a full or patially
   ///     decoded UUID.
   ///
-  /// @param[out] end
-  ///     If \a end is not nullptr, it will be filled in with the a
-  ///     pointer to the character after the last successfully decoded
-  ///     byte.
-  ///
   /// @return
-  ///     Returns the number of bytes that were successfully decoded
-  ///     which should be 16 if a full UUID value was properly decoded.
+  ///     The original string, with all decoded bytes removed.
   //------------------------------------------------------------------
-  static size_t DecodeUUIDBytesFromCString(const char *cstr,
-                                           ValueType &uuid_bytes,
-                                           const char **end,
-                                           uint32_t num_uuid_bytes = 16);
+  static llvm::StringRef
+  DecodeUUIDBytesFromString(llvm::StringRef str, ValueType &uuid_bytes,
 
 protected:
   //------------------------------------------------------------------
   // Classes that inherit from UUID can see and modify these
   //------------------------------------------------------------------
   uint32_t m_num_uuid_bytes; // Should be 16 or 20
   ValueType m_uuid;
 };

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

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,
-      const char *completion_str, // This is the argument we are completing
+      llvm::StringRef completion_str, // This is the argument we are completing
       int match_start_point,   // This is the point in the list of matches that
                                // you should start returning elements
       int max_return_elements, // This is the number of matches requested.
       lldb_private::SearchFilter
           *searcher, // A search filter to limit the search...
       bool &word_complete,
       lldb_private::StringList &matches); // The array of matches we return.
   typedef enum {
public:
 
   struct CommonCompletionElement {
     uint32_t type;
     CompletionCallback callback;
   };
 
   static bool InvokeCommonCompletionCallbacks(
       CommandInterpreter &interpreter, uint32_t completion_mask,
-      const char *completion_str, int match_start_point,
+      llvm::StringRef completion_str, int match_start_point,
       int max_return_elements, SearchFilter *searcher, bool &word_complete,
       StringList &matches);
 
   //----------------------------------------------------------------------
   // These are the generic completer functions:
   //----------------------------------------------------------------------
   static int DiskFiles(CommandInterpreter &interpreter,
-                       const char *partial_file_name, int match_start_point,
+                       llvm::StringRef partial_file_name, int match_start_point,
                        int max_return_elements, SearchFilter *searcher,
                        bool &word_complete, StringList &matches);
 
   static int DiskDirectories(CommandInterpreter &interpreter,
-                             const char *partial_file_name,
+                             llvm::StringRef partial_file_name,
                              int match_start_point, int max_return_elements,
                              SearchFilter *searcher, bool &word_complete,
                              StringList &matches);
 
   static int SourceFiles(CommandInterpreter &interpreter,
-                         const char *partial_file_name, int match_start_point,
-                         int max_return_elements, SearchFilter *searcher,
-                         bool &word_complete, StringList &matches);
+                         llvm::StringRef partial_file_name,
+                         int match_start_point, int max_return_elements,
+                         SearchFilter *searcher, bool &word_complete,
+                         StringList &matches);
 
   static int Modules(CommandInterpreter &interpreter,
-                     const char *partial_file_name, int match_start_point,
+                     llvm::StringRef partial_file_name, int match_start_point,
                      int max_return_elements, SearchFilter *searcher,
                      bool &word_complete, lldb_private::StringList &matches);
 
   static int Symbols(CommandInterpreter &interpreter,
-                     const char *partial_file_name, int match_start_point,
+                     llvm::StringRef partial_file_name, int match_start_point,
                      int max_return_elements, SearchFilter *searcher,
                      bool &word_complete, lldb_private::StringList &matches);
 
   static int SettingsNames(CommandInterpreter &interpreter,
-                           const char *partial_file_name, int match_start_point,
-                           int max_return_elements, SearchFilter *searcher,
-                           bool &word_complete,
+                           llvm::StringRef partial_file_name,
+                           int match_start_point, int max_return_elements,
+                           SearchFilter *searcher, bool &word_complete,
                            lldb_private::StringList &matches);
 
   static int PlatformPluginNames(CommandInterpreter &interpreter,
-                                 const char *partial_file_name,
+                                 llvm::StringRef partial_file_name,
                                  int match_start_point, int max_return_elements,
                                  SearchFilter *searcher, bool &word_complete,
                                  lldb_private::StringList &matches);
 
   static int ArchitectureNames(CommandInterpreter &interpreter,
-                               const char *partial_file_name,
+                               llvm::StringRef partial_file_name,
                                int match_start_point, int max_return_elements,
                                SearchFilter *searcher, bool &word_complete,
                                lldb_private::StringList &matches);
 
   static int VariablePath(CommandInterpreter &interpreter,
-                          const char *partial_file_name, int match_start_point,
-                          int max_return_elements, SearchFilter *searcher,
-                          bool &word_complete,
+                          llvm::StringRef partial_file_name,
+                          int match_start_point, int max_return_elements,
+                          SearchFilter *searcher, bool &word_complete,
                           lldb_private::StringList &matches);
 
   //----------------------------------------------------------------------
   // 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, const char *completion_str,
+    Completer(CommandInterpreter &interpreter, llvm::StringRef completion_str,
               int match_start_point, int max_return_elements,
               StringList &matches);
 
     ~Completer() override;
 
     CallbackReturn SearchCallback(SearchFilter &filter, SymbolContext &context,
                                   Address *addr, bool complete) override = 0;
 
public:
   };
 
   //----------------------------------------------------------------------
   // SourceFileCompleter implements the source file completer
   //----------------------------------------------------------------------
   class SourceFileCompleter : public Completer {
   public:
     SourceFileCompleter(CommandInterpreter &interpreter,
-                        bool include_support_files, const char *completion_str,
-                        int match_start_point, int max_return_elements,
-                        StringList &matches);
+                        bool include_support_files,
+                        llvm::StringRef completion_str, int match_start_point,
+                        int max_return_elements, StringList &matches);
 
     Searcher::Depth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
                                             Address *addr,
                                             bool complete) override;
 
     size_t 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, const char *completion_str,
-                    int match_start_point, int max_return_elements,
-                    StringList &matches);
+    ModuleCompleter(CommandInterpreter &interpreter,
+                    llvm::StringRef completion_str, int match_start_point,
+                    int max_return_elements, StringList &matches);
 
     Searcher::Depth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
                                             Address *addr,
                                             bool complete) override;
 
     size_t DoCompletion(SearchFilter *filter) override;
 
   private:
     const char *m_file_name;
     const char *m_dir_name;
 
     DISALLOW_COPY_AND_ASSIGN(ModuleCompleter);
   };
 
   //----------------------------------------------------------------------
   // SymbolCompleter implements the symbol completer
   //----------------------------------------------------------------------
   class SymbolCompleter : public Completer {
   public:
-    SymbolCompleter(CommandInterpreter &interpreter, const char *completion_str,
-                    int match_start_point, int max_return_elements,
-                    StringList &matches);
+    SymbolCompleter(CommandInterpreter &interpreter,
+                    llvm::StringRef completion_str, int match_start_point,
+                    int max_return_elements, StringList &matches);
 
     Searcher::Depth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
                                             Address *addr,
                                             bool complete) override;
 

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

public:
   Error
   SetValueFromString(const char *,
                      VarSetOperationType = eVarSetOperationAssign) = delete;
 
   virtual bool Clear() = 0;
 
   virtual lldb::OptionValueSP DeepCopy() const = 0;
 
-  virtual size_t AutoComplete(CommandInterpreter &interpreter, const char *s,
-                              int match_start_point, int max_return_elements,
-                              bool &word_complete, StringList &matches);
+  virtual size_t AutoComplete(CommandInterpreter &interpreter,
+                              llvm::StringRef s, int match_start_point,
+                              int max_return_elements, bool &word_complete,
+                              StringList &matches);
 
   //-----------------------------------------------------------------
   // Subclasses can override these functions
   //-----------------------------------------------------------------
   virtual lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
                                           const char *name, bool will_modify,
                                           Error &error) const {
     error.SetErrorStringWithFormat("'%s' is not a value subvalue", name);

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, const char *s,
+  size_t AutoComplete(CommandInterpreter &interpreter, llvm::StringRef s,
                       int match_start_point, int max_return_elements,
                       bool &word_complete, StringList &matches) override;
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 
   ArchSpec &GetCurrentValue() { return m_current_value; }

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

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

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, const char *s,
+  size_t AutoComplete(CommandInterpreter &interpreter, llvm::StringRef s,
                       int match_start_point, int max_return_elements,
                       bool &word_complete, StringList &matches) override;
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 
   enum_type operator=(enum_type 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, const char *s,
+  size_t AutoComplete(CommandInterpreter &interpreter, llvm::StringRef s,
                       int match_start_point, int max_return_elements,
                       bool &word_complete, StringList &matches) override;
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 
   FileSpec &GetCurrentValue() { return m_current_value; }

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

-//===-- OptionValueFormatEntity.h --------------------------------------*- C++
-//-*-===//
+//===-- OptionValueFormatEntity.h --------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
public:
   Error
   SetValueFromString(const char *,
                      VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override;
 
   lldb::OptionValueSP DeepCopy() const override;
 
-  size_t AutoComplete(CommandInterpreter &interpreter, const char *s,
+  size_t AutoComplete(CommandInterpreter &interpreter, llvm::StringRef s,
                       int match_start_point, int max_return_elements,
                       bool &word_complete, StringList &matches) override;
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 
   FormatEntity::Entry &GetCurrentValue() { return m_current_entry; }

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

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

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

-//===-- Variable.h ----------------------------------------------*- C++
-//-*-===//
+//===-- Variable.h -----------------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
public:
   typedef size_t (*GetVariableCallback)(void *baton, const char *name,
                                         VariableList &var_list);
 
   static Error GetValuesForVariableExpressionPath(
       const char *variable_expr_path, ExecutionContextScope *scope,
       GetVariableCallback callback, void *baton, VariableList &variable_list,
       ValueObjectList &valobj_list);
 
-  static size_t AutoComplete(const ExecutionContext &exe_ctx, const char *name,
-                             StringList &matches, bool &word_complete);
+  static size_t AutoComplete(const ExecutionContext &exe_ctx,
+                             llvm::StringRef name, StringList &matches,
+                             bool &word_complete);
 
   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/NameMatches.h

 //===-- NameMatches.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLDB_UTILITY_NAMEMATCHES_H
 #define LLDB_UTILITY_NAMEMATCHES_H
 
 #include "lldb/lldb-private-enumerations.h"
 
+#include "llvm/ADT/StringRef.h"
+
 namespace lldb_private {
-bool NameMatches(const char *name, NameMatchType match_type, const char *match);
+bool NameMatches(llvm::StringRef name, NameMatchType match_type,
+                 llvm::StringRef match);
 }
 
 #endif

lldb/trunk/source/Commands/CommandCompletions.cpp

CommandCompletions::g_common_completions[] = {
         {ePlatformPluginCompletion, CommandCompletions::PlatformPluginNames},
         {eArchitectureCompletion, CommandCompletions::ArchitectureNames},
         {eVariablePathCompletion, CommandCompletions::VariablePath},
         {eNoCompletion, nullptr} // This one has to be last in the list.
 };
 
 bool CommandCompletions::InvokeCommonCompletionCallbacks(
     CommandInterpreter &interpreter, uint32_t completion_mask,
-    const char *completion_str, int match_start_point, int max_return_elements,
-    SearchFilter *searcher, bool &word_complete, StringList &matches) {
+    llvm::StringRef completion_str, int match_start_point,
+    int max_return_elements, SearchFilter *searcher, bool &word_complete,
+    StringList &matches) {
   bool handled = false;
 
   if (completion_mask & eCustomCompletion)
     return false;
 
   for (int i = 0;; i++) {
     if (g_common_completions[i].type == eNoCompletion)
       break;
     else if ((g_common_completions[i].type & completion_mask) ==
                  g_common_completions[i].type &&
              g_common_completions[i].callback != nullptr) {
       handled = true;
       g_common_completions[i].callback(interpreter, completion_str,
                                        match_start_point, max_return_elements,
                                        searcher, word_complete, matches);
     }
   }
   return handled;
 }
 
 int CommandCompletions::SourceFiles(CommandInterpreter &interpreter,
-                                    const char *partial_file_name,
+                                    llvm::StringRef partial_file_name,
                                     int match_start_point,
                                     int max_return_elements,
                                     SearchFilter *searcher, bool &word_complete,
                                     StringList &matches) {
   word_complete = true;
   // Find some way to switch "include support files..."
   SourceFileCompleter completer(interpreter, false, partial_file_name,
                                 match_start_point, max_return_elements,
if (remainder[0] == '\0' || strstr(name, remainder) == name) {
     if (parameters->only_directories && !isa_directory)
       return FileSpec::eEnumerateDirectoryResultNext;
     parameters->matches->AppendString(partial_name_copy);
   }
 
   return FileSpec::eEnumerateDirectoryResultNext;
 }
 
-static int DiskFilesOrDirectories(const char *partial_file_name,
+static int DiskFilesOrDirectories(llvm::StringRef partial_file_name,
                                   bool only_directories, bool &saw_directory,
                                   StringList &matches) {
   // I'm going to  use the "glob" function with GLOB_TILDE for user directory
   // expansion.
   // If it is not defined on your host system, you'll need to implement it
   // yourself...
 
-  size_t partial_name_len = strlen(partial_file_name);
+  size_t partial_name_len = partial_file_name.size();
 
   if (partial_name_len >= PATH_MAX)
     return matches.GetSize();
 
   // This copy of the string will be cut up into the directory part, and the
-  // remainder.  end_ptr
-  // below will point to the place of the remainder in this string.  Then when
-  // we've resolved the
-  // containing directory, and opened it, we'll read the directory contents and
-  // overwrite the
-  // partial_name_copy starting from end_ptr with each of the matches.  Thus we
-  // will preserve
-  // the form the user originally typed.
+  // remainder.  end_ptr below will point to the place of the remainder in this
+  // string.  Then when we've resolved the containing directory, and opened it,
+  // we'll read the directory contents and overwrite the partial_name_copy
+  // starting from end_ptr with each of the matches.  Thus we will preserve the
+  // form the user originally typed.
 
   char partial_name_copy[PATH_MAX];
-  memcpy(partial_name_copy, partial_file_name, partial_name_len);
+  memcpy(partial_name_copy, partial_file_name.data(), partial_name_len);
   partial_name_copy[partial_name_len] = '\0';
 
   // We'll need to save a copy of the remainder for comparison, which we do
   // here.
   char remainder[PATH_MAX];
 
   // end_ptr will point past the last / in partial_name_copy, or if there is no
   // slash to the beginning of the string.
static int DiskFilesOrDirectories(llvm::StringRef partial_file_name,
 
   FileSpec::EnumerateDirectory(containing_part.c_str(), true, true, true,
                                DiskFilesOrDirectoriesCallback, &parameters);
 
   return matches.GetSize();
 }
 
 int CommandCompletions::DiskFiles(CommandInterpreter &interpreter,
-                                  const char *partial_file_name,
+                                  llvm::StringRef partial_file_name,
                                   int match_start_point,
                                   int max_return_elements,
                                   SearchFilter *searcher, bool &word_complete,
                                   StringList &matches) {
   int ret_val =
       DiskFilesOrDirectories(partial_file_name, false, word_complete, matches);
   word_complete = !word_complete;
   return ret_val;
 }
 
 int CommandCompletions::DiskDirectories(
-    CommandInterpreter &interpreter, const char *partial_file_name,
+    CommandInterpreter &interpreter, llvm::StringRef partial_file_name,
     int match_start_point, int max_return_elements, SearchFilter *searcher,
     bool &word_complete, StringList &matches) {
   int ret_val =
       DiskFilesOrDirectories(partial_file_name, true, word_complete, matches);
   word_complete = false;
   return ret_val;
 }
 
 int CommandCompletions::Modules(CommandInterpreter &interpreter,
-                                const char *partial_file_name,
+                                llvm::StringRef partial_file_name,
                                 int match_start_point, int max_return_elements,
                                 SearchFilter *searcher, bool &word_complete,
                                 StringList &matches) {
   word_complete = true;
   ModuleCompleter completer(interpreter, partial_file_name, match_start_point,
                             max_return_elements, matches);
 
   if (searcher == nullptr) {
     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
     completer.DoCompletion(&null_searcher);
   } else {
     completer.DoCompletion(searcher);
   }
   return matches.GetSize();
 }
 
 int CommandCompletions::Symbols(CommandInterpreter &interpreter,
-                                const char *partial_file_name,
+                                llvm::StringRef partial_file_name,
                                 int match_start_point, int max_return_elements,
                                 SearchFilter *searcher, bool &word_complete,
                                 StringList &matches) {
   word_complete = true;
   SymbolCompleter completer(interpreter, partial_file_name, match_start_point,
                             max_return_elements, matches);
 
   if (searcher == nullptr) {
     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
     completer.DoCompletion(&null_searcher);
   } else {
     completer.DoCompletion(searcher);
   }
   return matches.GetSize();
 }
 
 int CommandCompletions::SettingsNames(
-    CommandInterpreter &interpreter, const char *partial_setting_name,
+    CommandInterpreter &interpreter, llvm::StringRef partial_setting_name,
     int match_start_point, int max_return_elements, SearchFilter *searcher,
     bool &word_complete, StringList &matches) {
   // Cache the full setting name list
   static StringList g_property_names;
   if (g_property_names.GetSize() == 0) {
     // Generate the full setting name list on demand
     lldb::OptionValuePropertiesSP properties_sp(
         interpreter.GetDebugger().GetValueProperties());
     if (properties_sp) {
       StreamString strm;
       properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName);
       const std::string &str = strm.GetString();
       g_property_names.SplitIntoLines(str.c_str(), str.size());
     }
   }
 
   size_t exact_matches_idx = SIZE_MAX;
   const size_t num_matches = g_property_names.AutoComplete(
       partial_setting_name, matches, exact_matches_idx);
   word_complete = exact_matches_idx != SIZE_MAX;
   return num_matches;
 }
 
 int CommandCompletions::PlatformPluginNames(
-    CommandInterpreter &interpreter, const char *partial_name,
+    CommandInterpreter &interpreter, llvm::StringRef partial_name,
     int match_start_point, int max_return_elements, SearchFilter *searcher,
     bool &word_complete, lldb_private::StringList &matches) {
   const uint32_t num_matches =
       PluginManager::AutoCompletePlatformName(partial_name, matches);
   word_complete = num_matches == 1;
   return num_matches;
 }
 
 int CommandCompletions::ArchitectureNames(
-    CommandInterpreter &interpreter, const char *partial_name,
+    CommandInterpreter &interpreter, llvm::StringRef partial_name,
     int match_start_point, int max_return_elements, SearchFilter *searcher,
     bool &word_complete, lldb_private::StringList &matches) {
   const uint32_t num_matches = ArchSpec::AutoComplete(partial_name, matches);
   word_complete = num_matches == 1;
   return num_matches;
 }
 
 int CommandCompletions::VariablePath(
-    CommandInterpreter &interpreter, const char *partial_name,
+    CommandInterpreter &interpreter, llvm::StringRef partial_name,
     int match_start_point, int max_return_elements, SearchFilter *searcher,
     bool &word_complete, lldb_private::StringList &matches) {
   return Variable::AutoComplete(interpreter.GetExecutionContext(), partial_name,
                                 matches, word_complete);
 }
 
 CommandCompletions::Completer::Completer(CommandInterpreter &interpreter,
-                                         const char *completion_str,
+                                         llvm::StringRef completion_str,
                                          int match_start_point,
                                          int max_return_elements,
                                          StringList &matches)
     : m_interpreter(interpreter), m_completion_str(completion_str),
       m_match_start_point(match_start_point),
       m_max_return_elements(max_return_elements), m_matches(matches) {}
 
 CommandCompletions::Completer::~Completer() = default;
 
 //----------------------------------------------------------------------
 // SourceFileCompleter
 //----------------------------------------------------------------------
 
 CommandCompletions::SourceFileCompleter::SourceFileCompleter(
     CommandInterpreter &interpreter, bool include_support_files,
-    const char *completion_str, int match_start_point, int max_return_elements,
-    StringList &matches)
+    llvm::StringRef completion_str, int match_start_point,
+    int max_return_elements, StringList &matches)
     : CommandCompletions::Completer(interpreter, completion_str,
                                     match_start_point, max_return_elements,
                                     matches),
       m_include_support_files(include_support_files), m_matching_files() {
   FileSpec partial_spec(m_completion_str, false);
   m_file_name = partial_spec.GetFilename().GetCString();
   m_dir_name = partial_spec.GetDirectory().GetCString();
 }

 static bool regex_chars(const char comp) {
   return (comp == '[' || comp == ']' || comp == '(' || comp == ')' ||
           comp == '{' || comp == '}' || comp == '+' || comp == '.' ||
           comp == '*' || comp == '|' || comp == '^' || comp == '$' ||
           comp == '\\' || comp == '?');
 }
 
 CommandCompletions::SymbolCompleter::SymbolCompleter(
-    CommandInterpreter &interpreter, const char *completion_str,
+    CommandInterpreter &interpreter, llvm::StringRef completion_str,
     int match_start_point, int max_return_elements, StringList &matches)
     : CommandCompletions::Completer(interpreter, completion_str,
                                     match_start_point, max_return_elements,
                                     matches) {
   std::string regex_str;
-  if (completion_str && completion_str[0]) {
+  if (!completion_str.empty()) {
     regex_str.append("^");
     regex_str.append(completion_str);
   } else {
     // Match anything since the completion string is empty
     regex_str.append(".");
   }
   std::string::iterator pos =
       find_if(regex_str.begin() + 1, regex_str.end(), regex_chars);
size_t CommandCompletions::SymbolCompleter::DoCompletion(SearchFilter *filter) {
 
   return m_matches.GetSize();
 }
 
 //----------------------------------------------------------------------
 // ModuleCompleter
 //----------------------------------------------------------------------
 CommandCompletions::ModuleCompleter::ModuleCompleter(
-    CommandInterpreter &interpreter, const char *completion_str,
+    CommandInterpreter &interpreter, llvm::StringRef completion_str,
     int match_start_point, int max_return_elements, StringList &matches)
     : CommandCompletions::Completer(interpreter, completion_str,
                                     match_start_point, max_return_elements,
                                     matches) {
   FileSpec partial_spec(m_completion_str, false);
   m_file_name = partial_spec.GetFilename().GetCString();
   m_dir_name = partial_spec.GetDirectory().GetCString();
 }

lldb/trunk/source/Core/ArchSpec.cpp

 
 struct ArchDefinition {
   ArchitectureType type;
   size_t num_entries;
   const ArchDefinitionEntry *entries;
   const char *name;
 };
 
-size_t ArchSpec::AutoComplete(const char *name, StringList &matches) {
-  if (name && name[0]) {
+size_t ArchSpec::AutoComplete(llvm::StringRef name, StringList &matches) {
+  if (!name.empty()) {
     for (uint32_t i = 0; i < llvm::array_lengthof(g_core_definitions); ++i) {
       if (NameMatches(g_core_definitions[i].name, eNameMatchStartsWith, name))
         matches.AppendString(g_core_definitions[i].name);
     }
   } else {
     for (uint32_t i = 0; i < llvm::array_lengthof(g_core_definitions); ++i)
       matches.AppendString(g_core_definitions[i].name);
   }

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

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(const char *name,
+size_t PluginManager::AutoCompletePlatformName(llvm::StringRef name,
                                                StringList &matches) {
-  if (name) {
-    std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
-    PlatformInstances &instances = GetPlatformInstances();
-    llvm::StringRef name_sref(name);
+  if (name.empty())
+    return matches.GetSize();
+
 
-    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());
-    }
-  }
   return matches.GetSize();
 }
 
 #pragma mark Process
 
 struct ProcessInstance {
   ProcessInstance()
       : name(), description(), create_callback(nullptr),

lldb/trunk/source/Core/StringList.cpp

 StringList &StringList::operator=(const std::vector<std::string> &rhs) {
   Clear();
   for (const auto &s : rhs)
     m_strings.push_back(s);
 
   return *this;
 }
 
-size_t StringList::AutoComplete(const char *s, StringList &matches,
+size_t StringList::AutoComplete(llvm::StringRef s, StringList &matches,
                                 size_t &exact_idx) const {
   matches.Clear();
   exact_idx = SIZE_MAX;
-  if (s && s[0]) {
-    const size_t s_len = strlen(s);
-    const size_t num_strings = m_strings.size();
+  if (s.empty()) {
+    // No string, so it matches everything
+    matches = *this;
+    return matches.GetSize();
+  }
+
+  const size_t s_len = s.size();
 
-    for (size_t i = 0; i < num_strings; ++i) {
-      if (m_strings[i].find(s) == 0) {
-        if (exact_idx == SIZE_MAX && m_strings[i].size() == s_len)
-          exact_idx = matches.GetSize();
-        matches.AppendString(m_strings[i]);
-      }
-    }
-  } else {
-    // No string, so it matches everything
-    matches = *this;
-  }
   return matches.GetSize();
 }
 
 void StringList::LogDump(Log *log, const char *name) {
   if (!log)
     return;
 
   StreamString strm;

lldb/trunk/source/Core/UUID.cpp

 
 static inline int xdigit_to_int(char ch) {
   ch = tolower(ch);
   if (ch >= 'a' && ch <= 'f')
     return 10 + ch - 'a';
   return ch - '0';
 }
 
-size_t UUID::DecodeUUIDBytesFromCString(const char *p, ValueType &uuid_bytes,
-                                        const char **end,
+llvm::StringRef UUID::DecodeUUIDBytesFromString(llvm::StringRef p,
+                                                ValueType &uuid_bytes,
                                                 uint32_t num_uuid_bytes) {
+  ::memset(uuid_bytes, 0, sizeof(uuid_bytes));
   size_t uuid_byte_idx = 0;
-  if (p) {
-    while (*p) {
-      if (isxdigit(p[0]) && isxdigit(p[1])) {
-        int hi_nibble = xdigit_to_int(p[0]);
-        int lo_nibble = xdigit_to_int(p[1]);
-        // Translate the two hex nibble characters into a byte
-        uuid_bytes[uuid_byte_idx] = (hi_nibble << 4) + lo_nibble;
+  while (!p.empty()) {
 
-        // Skip both hex digits
-        p += 2;
+      p = p.drop_front(2);
 
-        // Increment the byte that we are decoding within the UUID value
-        // and break out if we are done
-        if (++uuid_byte_idx == num_uuid_bytes)
-          break;
-      } else if (*p == '-') {
-        // Skip dashes
-        p++;
-      } else {
-        // UUID values can only consist of hex characters and '-' chars
-        break;
-      }
-    }
-  }
-  if (end)
-    *end = p;
+    } else if (p.front() == '-') {
+      p = p.drop_front();
+
   // Clear trailing bytes to 0.
   for (uint32_t i = uuid_byte_idx; i < sizeof(ValueType); i++)
     uuid_bytes[i] = 0;
-  return uuid_byte_idx;
+  return p;
 }
 size_t UUID::SetFromCString(const char *cstr, uint32_t num_uuid_bytes) {
   if (cstr == NULL)
     return 0;
 
-  const char *p = cstr;
+  llvm::StringRef orig(cstr);
+  llvm::StringRef p = orig;
 
   // Skip leading whitespace characters
-  while (isspace(*p))
-    ++p;
+  p = p.ltrim();
 
-  const size_t uuid_byte_idx =
-      UUID::DecodeUUIDBytesFromCString(p, m_uuid, &p, num_uuid_bytes);
+  llvm::StringRef rest =
+      UUID::DecodeUUIDBytesFromString(p, m_uuid, num_uuid_bytes);
+  size_t bytes_decoded = p.size() - rest.size();
 
   // If we successfully decoded a UUID, return the amount of characters that
   // were consumed
-  if (uuid_byte_idx == num_uuid_bytes) {
+  if (bytes_decoded == num_uuid_bytes) {
     m_num_uuid_bytes = num_uuid_bytes;
-    return p - cstr;
+    return orig.size() - rest.size();
   }
 
   // Else return zero to indicate we were not able to parse a UUID value
   return 0;
 }
 }
 
 bool lldb_private::operator==(const lldb_private::UUID &lhs,

lldb/trunk/source/Interpreter/CommandObject.cpp

bool CommandObjectRaw::Execute(const char *args_string,
   }
   return handled;
 }
 
 static llvm::StringRef arch_helper() {
   static StreamString g_archs_help;
   if (g_archs_help.Empty()) {
     StringList archs;
-    ArchSpec::AutoComplete(nullptr, archs);
+    ArchSpec::AutoComplete(llvm::StringRef(), archs);
     g_archs_help.Printf("These are the supported architecture names:\n");
     archs.Join("\n", g_archs_help);
   }
   return g_archs_help.GetString();
 }
 
 CommandObject::ArgumentTableEntry CommandObject::g_arguments_data[] = {
     // clang-format off

lldb/trunk/source/Interpreter/OptionValue.cpp

if (dumped_something)
       strm.PutChar('.');
     else
       dumped_something = true;
     strm << name;
   }
   return dumped_something;
 }
 
-size_t OptionValue::AutoComplete(CommandInterpreter &interpreter, const char *s,
-                                 int match_start_point, int max_return_elements,
-                                 bool &word_complete, StringList &matches) {
+size_t OptionValue::AutoComplete(CommandInterpreter &interpreter,
+                                 llvm::StringRef s, int match_start_point,
+                                 int max_return_elements, bool &word_complete,
+                                 StringList &matches) {
   word_complete = false;
   matches.Clear();
   return matches.GetSize();
 }
 
 Error OptionValue::SetValueFromString(llvm::StringRef value,
                                       VarSetOperationType op) {
   Error error;

lldb/trunk/source/Interpreter/OptionValueArch.cpp

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

lldb/trunk/source/Interpreter/OptionValueBoolean.cpp

Error OptionValueBoolean::SetValueFromString(llvm::StringRef value_str,
   }
   return error;
 }
 
 lldb::OptionValueSP OptionValueBoolean::DeepCopy() const {
   return OptionValueSP(new OptionValueBoolean(*this));
 }
 
-size_t OptionValueBoolean::AutoComplete(CommandInterpreter &interpreter,
-                                        const char *s, int match_start_point,
-                                        int max_return_elements,
-                                        bool &word_complete,
-                                        StringList &matches) {
+size_t OptionValueBoolean::AutoComplete(
+    CommandInterpreter &interpreter, llvm::StringRef s, int match_start_point,
+    int max_return_elements, bool &word_complete, StringList &matches) {
   word_complete = false;
   matches.Clear();
-  struct StringEntry {
-    const char *string;
-    const size_t length;
-  };
-  static const StringEntry g_autocomplete_entries[] = {
-      {"true", 4}, {"false", 5}, {"on", 2}, {"off", 3},
-      {"yes", 3},  {"no", 2},    {"1", 1},  {"0", 1},
-  };
-  const size_t k_num_autocomplete_entries =
-      llvm::array_lengthof(g_autocomplete_entries);
-
-  if (s && s[0]) {
-    const size_t s_len = strlen(s);
-    for (size_t i = 0; i < k_num_autocomplete_entries; ++i) {
-      if (s_len <= g_autocomplete_entries[i].length)
-        if (::strncasecmp(s, g_autocomplete_entries[i].string, s_len) == 0)
-          matches.AppendString(g_autocomplete_entries[i].string);
-    }
-  } else {
-    // only suggest "true" or "false" by default
-    for (size_t i = 0; i < 2; ++i)
-      matches.AppendString(g_autocomplete_entries[i].string);
+  static const llvm::StringRef g_autocomplete_entries[] = {
+      "true", "false", "on", "off", "yes", "no", "1", "0"};
+
+  auto entries = llvm::makeArrayRef(g_autocomplete_entries);
+
+  if (s.empty())
+    entries = entries.take_front(2);
+
+  for (auto entry : entries) {
+    if (entry.startswith_lower(s))
+      matches.AppendString(entry);
   }
   return matches.GetSize();
 }

lldb/trunk/source/Interpreter/OptionValueEnumeration.cpp

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

lldb/trunk/source/Interpreter/OptionValueFileSpec.cpp

Error OptionValueFileSpec::SetValueFromString(llvm::StringRef value,
   }
   return error;
 }
 
 lldb::OptionValueSP OptionValueFileSpec::DeepCopy() const {
   return OptionValueSP(new OptionValueFileSpec(*this));
 }
 
-size_t OptionValueFileSpec::AutoComplete(CommandInterpreter &interpreter,
-                                         const char *s, int match_start_point,
-                                         int max_return_elements,
-                                         bool &word_complete,
-                                         StringList &matches) {
+size_t OptionValueFileSpec::AutoComplete(
+    CommandInterpreter &interpreter, llvm::StringRef s, int match_start_point,
+    int max_return_elements, bool &word_complete, StringList &matches) {
   word_complete = false;
   matches.Clear();
   CommandCompletions::InvokeCommonCompletionCallbacks(
       interpreter, m_completion_mask, s, match_start_point, max_return_elements,
       nullptr, word_complete, matches);
   return matches.GetSize();
 }
 

lldb/trunk/source/Interpreter/OptionValueFormatEntity.cpp

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

lldb/trunk/source/Interpreter/OptionValueUUID.cpp

Error OptionValueUUID::SetValueFromString(llvm::StringRef value,
   return error;
 }
 
 lldb::OptionValueSP OptionValueUUID::DeepCopy() const {
   return OptionValueSP(new OptionValueUUID(*this));
 }
 
 size_t OptionValueUUID::AutoComplete(CommandInterpreter &interpreter,
-                                     const char *s, int match_start_point,
+                                     llvm::StringRef s, int match_start_point,
                                      int max_return_elements,
                                      bool &word_complete, StringList &matches) {
   word_complete = false;
   matches.Clear();
   ExecutionContext exe_ctx(interpreter.GetExecutionContext());
   Target *target = exe_ctx.GetTargetPtr();
   if (target) {
     const size_t num_modules = target->GetImages().GetSize();
     if (num_modules > 0) {
       UUID::ValueType uuid_bytes;
-      const size_t num_bytes_decoded =
-          UUID::DecodeUUIDBytesFromCString(s, uuid_bytes, nullptr);
+      llvm::StringRef rest = UUID::DecodeUUIDBytesFromString(s, uuid_bytes);
+      const size_t num_bytes_decoded = s.size() - rest.size();
       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()) {
             bool add_uuid = false;
             if (num_bytes_decoded == 0)
               add_uuid = true;

lldb/trunk/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

-//===-- EmulateInstructionARM64.cpp -------------------------------*- C++
-//-*-===//
+//===-- EmulateInstructionARM64.cpp ------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

lldb/trunk/source/Symbol/Variable.cpp

 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
+#include "llvm/ADT/Twine.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Variable constructor
 //----------------------------------------------------------------------
 Variable::Variable(
     lldb::user_id_t uid, const char *name,
if (sc.module_sp == address.GetModule()) {
       return m_location.DumpLocationForAddress(
           s, eDescriptionLevelBrief, LLDB_INVALID_ADDRESS, file_addr, abi);
     }
   }
   return false;
 }
 
 static void PrivateAutoComplete(
-    StackFrame *frame, const std::string &partial_path,
-    const std::string
+    StackFrame *frame, llvm::StringRef partial_path,
+    const llvm::Twine
         &prefix_path, // Anything that has been resolved already will be in here
     const CompilerType &compiler_type,
     StringList &matches, bool &word_complete);
 
 static void PrivateAutoCompleteMembers(
     StackFrame *frame, const std::string &partial_member_name,
-    const std::string &partial_path,
-    const std::string
+    llvm::StringRef partial_path,
+    const llvm::Twine
         &prefix_path, // Anything that has been resolved already will be in here
     const CompilerType &compiler_type,
     StringList &matches, bool &word_complete);
 
 static void PrivateAutoCompleteMembers(
     StackFrame *frame, const std::string &partial_member_name,
-    const std::string &partial_path,
-    const std::string
+    llvm::StringRef partial_path,
+    const llvm::Twine
         &prefix_path, // Anything that has been resolved already will be in here
     const CompilerType &compiler_type,
     StringList &matches, bool &word_complete) {
 
   // We are in a type parsing child members
   const uint32_t num_bases = compiler_type.GetNumDirectBaseClasses();
 
   if (num_bases > 0) {
for (uint32_t i = 0; i < num_fields; ++i) {
           member_name.find(partial_member_name) == 0) {
         if (member_name == partial_member_name) {
           PrivateAutoComplete(
               frame, partial_path,
               prefix_path + member_name, // Anything that has been resolved
                                          // already will be in here
               member_compiler_type.GetCanonicalType(), matches, word_complete);
         } else {
-          matches.AppendString(prefix_path + member_name);
+          matches.AppendString((prefix_path + member_name).str());
         }
       }
     }
   }
 }
 
 static void PrivateAutoComplete(
-    StackFrame *frame, const std::string &partial_path,
-    const std::string
+    StackFrame *frame, llvm::StringRef partial_path,
+    const llvm::Twine
         &prefix_path, // Anything that has been resolved already will be in here
     const CompilerType &compiler_type,
     StringList &matches, bool &word_complete) {
   //    printf ("\nPrivateAutoComplete()\n\tprefix_path = '%s'\n\tpartial_path =
   //    '%s'\n", prefix_path.c_str(), partial_path.c_str());
   std::string remaining_partial_path;
 
   const lldb::TypeClass type_class = compiler_type.GetTypeClass();
   if (partial_path.empty()) {
     if (compiler_type.IsValid()) {
       switch (type_class) {
       default:
       case eTypeClassArray:
       case eTypeClassBlockPointer:
       case eTypeClassBuiltin:
       case eTypeClassComplexFloat:
       case eTypeClassComplexInteger:
       case eTypeClassEnumeration:
       case eTypeClassFunction:
       case eTypeClassMemberPointer:
       case eTypeClassReference:
       case eTypeClassTypedef:
       case eTypeClassVector: {
-        matches.AppendString(prefix_path);
+        matches.AppendString(prefix_path.str());
         word_complete = matches.GetSize() == 1;
       } break;
 
       case eTypeClassClass:
       case eTypeClassStruct:
       case eTypeClassUnion:
-        if (prefix_path.back() != '.')
-          matches.AppendString(prefix_path + '.');
+        if (prefix_path.str().back() != '.')
+          matches.AppendString((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) > 0)
-          matches.AppendString(prefix_path + "->");
+          matches.AppendString((prefix_path + "->").str());
         else {
-          matches.AppendString(prefix_path);
+          matches.AppendString(prefix_path.str());
           word_complete = true;
         }
       } break;
       }
     } else {
       if (frame) {
         const bool get_file_globals = true;
 
         VariableList *variable_list = frame->GetVariableList(get_file_globals);
 
         if (variable_list) {
           const size_t num_variables = variable_list->GetSize();
           for (size_t i = 0; i < num_variables; ++i) {
             Variable *variable = variable_list->GetVariableAtIndex(i).get();
             matches.AppendString(variable->GetName().AsCString());
           }
         }
       }
     }
   } else {
     const char ch = partial_path[0];
     switch (ch) {
     case '*':
-      if (prefix_path.empty()) {
-        PrivateAutoComplete(frame, partial_path.substr(1), std::string("*"),
-                            compiler_type, matches, word_complete);
+      if (prefix_path.str().empty()) {
+        PrivateAutoComplete(frame, partial_path.substr(1), "*", compiler_type,
+                            matches, word_complete);
       }
       break;
 
     case '&':
-      if (prefix_path.empty()) {
+      if (prefix_path.isTriviallyEmpty()) {
         PrivateAutoComplete(frame, partial_path.substr(1), std::string("&"),
                             compiler_type, matches, word_complete);
       }
       break;
 
     case '-':
-      if (partial_path[1] == '>' && !prefix_path.empty()) {
+      if (partial_path[1] == '>' && !prefix_path.str().empty()) {
         switch (type_class) {
         case lldb::eTypeClassPointer: {
           CompilerType pointee_type(compiler_type.GetPointeeType());
           if (partial_path[2]) {
             // If there is more after the "->", then search deeper
             PrivateAutoComplete(
                 frame, partial_path.substr(2), prefix_path + "->",
                 pointee_type.GetCanonicalType(), matches, word_complete);
default:
                       variable_type->GetForwardCompilerType());
                   PrivateAutoComplete(
                       frame, remaining_partial_path,
                       prefix_path + token, // Anything that has been resolved
                                            // already will be in here
                       variable_compiler_type.GetCanonicalType(), matches,
                       word_complete);
                 } else {
-                  matches.AppendString(prefix_path + variable_name);
+                  matches.AppendString((prefix_path + variable_name).str());
                 }
               } else if (remaining_partial_path.empty()) {
-                matches.AppendString(prefix_path + variable_name);
+                matches.AppendString((prefix_path + variable_name).str());
               }
             }
           }
         }
       }
       break;
     }
   }
 }
 
 size_t Variable::AutoComplete(const ExecutionContext &exe_ctx,
-                              const char *partial_path_cstr,
-                              StringList &matches, bool &word_complete) {
+                              llvm::StringRef partial_path, StringList &matches,
+                              bool &word_complete) {
   word_complete = false;
-  std::string partial_path;
-  std::string prefix_path;
   CompilerType compiler_type;
-  if (partial_path_cstr && partial_path_cstr[0])
-    partial_path = partial_path_cstr;
 
-  PrivateAutoComplete(exe_ctx.GetFramePtr(), partial_path, prefix_path,
-                      compiler_type, matches, word_complete);
+  PrivateAutoComplete(exe_ctx.GetFramePtr(), partial_path, "", compiler_type,
+                      matches, word_complete);
 
   return matches.GetSize();
 }

lldb/trunk/source/Utility/NameMatches.cpp

 //===-- NameMatches.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Core/RegularExpression.h"
 
 #include "llvm/ADT/StringRef.h"
 
 using namespace lldb_private;
 
-bool lldb_private::NameMatches(const char *name, NameMatchType match_type,
-                               const char *match) {
+bool lldb_private::NameMatches(llvm::StringRef name, NameMatchType match_type,
+                               llvm::StringRef match) {
   if (match_type == eNameMatchIgnore)
     return true;
 
   if (name == match)
     return true;
 
-  if (name && match) {
-    llvm::StringRef name_sref(name);
-    llvm::StringRef match_sref(match);
-    switch (match_type) {
-    case eNameMatchIgnore: // This case cannot occur: tested before
-      return true;
-    case eNameMatchEquals:
-      return name_sref == match_sref;
-    case eNameMatchContains:
-      return name_sref.find(match_sref) != llvm::StringRef::npos;
-    case eNameMatchStartsWith:
-      return name_sref.startswith(match_sref);
-    case eNameMatchEndsWith:
-      return name_sref.endswith(match_sref);
-    case eNameMatchRegularExpression: {
-      RegularExpression regex(match_sref);
-      return regex.Execute(name_sref);
-    } break;
-    }
-  }
+  if (name.empty() || match.empty())
+    return false;
+
+    return name == match;
+    return name.contains(match);
+    return name.startswith(match);
+    return name.endswith(match);
+    RegularExpression regex(match);
+    return regex.Execute(name);
   return false;
 }