[lldb] tab completion for class `CommandObjectTypeFormatterDelete`

[MrHate]

Summary

1. Added a dedicated completion to class CommandObjectTypeFormatterDelete which can be used by these commands: type filter/format/summary/synthetic delete;
2. Added a related test case.

[teemperor]

I just realized those patches probably conflict with the refactoring I'm doing with that code at the moment. I'll take care of the conflicts in your patches, but if you can push them back and maybe do other completions first then that would help a lot :)

[JDevlieghere]

lldb/include/lldb/DataFormatters/FormattersContainer.h

231

Please make this a Doxygen comment (///).

lldb/source/Commands/CommandObjectType.cpp

791

This is a lot of code duplication. Cann you hide this behind a macro? I'm thinking of something like:

#define CHECK_MASK(MASK, VALUE) MASK & VALUE == VALUE

[MrHate]

• Made the comment for EmptyStruct a Doxygen comment;
• Refactored m_formatter_kind_mask check with a macro CHECK_FORMATTER_KIND_MASK.

[teemperor]

LGTM

[MrHate]

• Rebased the patch with the latest master branch and refactored FormattersContainer::AutoComplete with the latest interface.

lldb/include/lldb/DataFormatters/FormattersContainer.h

void ForEach(ForEachCallback callback) {
     }
   }
 
   uint32_t GetCount() {
     std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     return m_map.size();
   }
 
+  void AutoComplete(CompletionRequest &request) {
+    ForEach([&request](const TypeMatcher &matcher, const ValueSP &value) {
+      request.TryCompleteCurrentArg(matcher.GetMatchString().GetStringRef());
+      return true;
+    });
+  }
+
 protected:
   FormattersContainer(const FormattersContainer &) = delete;
   const FormattersContainer &operator=(const FormattersContainer &) = delete;
 
   bool Get(const FormattersMatchVector &candidates, ValueSP &entry) {
     for (const FormattersMatchCandidate &candidate : candidates) {
       if (Get(candidate.GetTypeName(), entry)) {
         if (candidate.IsMatch(entry) == false) {
           entry.reset();
           continue;
         } else {
           return true;
         }
       }
     }
     return false;
   }
 
   MapType m_map;
   std::recursive_mutex m_map_mutex;
   IFormatChangeListener *listener;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_DATAFORMATTERS_FORMATTERSCONTAINER_H

lldb/source/Commands/CommandObjectType.cpp

 #include "lldb/Utility/StringList.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 #include <algorithm>
 #include <functional>
 #include <memory>
 
+#define CHECK_FORMATTER_KIND_MASK(VAL)                                         \
+  ((m_formatter_kind_mask & (VAL)) == (VAL))
+
 using namespace lldb;
 using namespace lldb_private;
 
 class ScriptAddOptions {
 public:
   TypeSummaryImpl::Flags m_flags;
   StringList m_target_types;
   bool m_regex;
CommandObjectTypeFormatterDelete(CommandInterpreter &interpreter,
 
     type_arg.push_back(type_style_arg);
 
     m_arguments.push_back(type_arg);
   }
 
   ~CommandObjectTypeFormatterDelete() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    if (request.GetCursorIndex())
+      return;
+
+    DataVisualization::Categories::ForEach(
+        [this, &request](const lldb::TypeCategoryImplSP &category_sp) {
+          if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemValue))
+            category_sp->GetTypeFormatsContainer()->AutoComplete(request);
+          if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexValue))
+            category_sp->GetRegexTypeFormatsContainer()->AutoComplete(request);
+
+          if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemSummary))
+            category_sp->GetTypeSummariesContainer()->AutoComplete(request);
+          if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexSummary))
+            category_sp->GetRegexTypeSummariesContainer()->AutoComplete(
+                request);
+
+          if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemFilter))
+            category_sp->GetTypeFiltersContainer()->AutoComplete(request);
+          if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexFilter))
+            category_sp->GetRegexTypeFiltersContainer()->AutoComplete(request);
+
+          if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemSynth))
+            category_sp->GetTypeSyntheticsContainer()->AutoComplete(request);
+          if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexSynth))
+            category_sp->GetRegexTypeSyntheticsContainer()->AutoComplete(
+                request);
+          return true;
+        });
+  }
+
 protected:
   virtual bool FormatterSpecificDeletion(ConstString typeCS) { return false; }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
 
     if (argc != 1) {
       result.AppendErrorWithFormat("%s takes 1 arg.\n", m_cmd_name.c_str());

lldb/test/API/functionalities/completion/TestCompletion.py

def test_symbol_name(self):
         self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.complete_from_to('breakpoint set -n Fo',
                               'breakpoint set -n Foo::Bar(int,\\ int)',
                               turn_off_re_match=True)
         # No completion for Qu because the candidate is
         # (anonymous namespace)::Quux().
         self.complete_from_to('breakpoint set -n Qu', '')
 
+    def test_completion_type_formatter_delete(self):
+        self.runCmd('type filter add --child a Aoo')
+        self.complete_from_to('type filter delete ', ['Aoo'])
+        self.runCmd('type filter add --child b -x Boo')
+        self.complete_from_to('type filter delete ', ['Boo'])
+
+        self.runCmd('type format add -f hex Coo')
+        self.complete_from_to('type format delete ', ['Coo'])
+        self.runCmd('type format add -f hex -x Doo')
+        self.complete_from_to('type format delete ', ['Doo'])
+
+        self.runCmd('type summary add -c Eoo')
+        self.complete_from_to('type summary delete ', ['Eoo'])
+        self.runCmd('type summary add -x -c Foo')
+        self.complete_from_to('type summary delete ', ['Foo'])
+
+        self.runCmd('type synthetic add Goo -l test')
+        self.complete_from_to('type synthetic delete ', ['Goo'])
+        self.runCmd('type synthetic add -x Hoo -l test')
+        self.complete_from_to('type synthetic delete ', ['Hoo'])
+
     @skipIf(archs=no_match(['x86_64']))
     def test_register_read_and_write_on_x86(self):
         """Test the completion of the commands register read and write on x86"""
 
         # The tab completion for "register read/write"  won't work without a running process.
         self.complete_from_to('register read ',
                               'register read ')
         self.complete_from_to('register write ',