Fix the help for "type X delete" to make the -a & -w behaviors clear

[jingham]

Summary

If you run:

(lldb) type summary delete Foo

that will only search for the type summary for Foo in the "default" category. That's by design, since this is "delete" you wouldn't want to accidentally delete a format it might be hard to get back, so making you specify the category or say "all" explicitly is a good safeguard. But the help is not at all clear that that's how it works and it has confused several people now.

This patch fixes the help strings. Since all the type X delete commands go through a common base, I centralized the help output in the base class so the help would be consistent. I also removed an unused macro, and changed where we were calling these formatter_kind_mask to be formatter_kind since we only use them as a single enum element, we never use them as masks in this context.

[bulbazord]

lldb/source/Commands/CommandObjectType.cpp

112–113

maybe add an llvm_unreachable after the switch statement?

886–892

You could define these in the class and not out-of-line if you use constexpr. So for example, above in the class you can do:

static constexpr const char *g_short_help_template = "Delete an existing %s for a type.";

[jingham]

Adopt suggestions from Alex.

[jingham]

lldb/source/Commands/CommandObjectType.cpp

886–892

That's neat though I'm not 100% sure why it has to be so ugly...

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;
   FormatterMatchType m_match_type;
if (next == "int" || next == "short" || next == "char" || next == "long") {
           "name use  quotes, as in \"unsigned %s\"\n",
           next.str().c_str(), next.str().c_str());
       return true;
     }
   }
   return false;
 }
 
+const char *FormatCategoryToString(FormatCategoryItem item, bool long_name) {
+  switch (item) {
+  case eFormatCategoryItemSummary:
+    return "summary";
+  case eFormatCategoryItemFilter:
+    return "filter";
+  case eFormatCategoryItemSynth:
+    if (long_name)
+      return "synthetic child provider";
+    return "synthetic";
+  case eFormatCategoryItemFormat:
+    return "format";
+  }
+  llvm_unreachable("Fully covered switch above!");
+};
+
 #define LLDB_OPTIONS_type_summary_add
 #include "CommandOptions.inc"
 
 class CommandObjectTypeSummaryAdd : public CommandObjectParsed,
                                     public IOHandlerDelegateMultiline {
 private:
   class CommandOptions : public Options {
   public:
public:
     // Instance variables to hold the values for command options.
 
     bool m_delete_all;
     std::string m_category;
     lldb::LanguageType m_language;
   };
 
   CommandOptions m_options;
-  uint32_t m_formatter_kind_mask;
+  FormatCategoryItem m_formatter_kind;
 
   Options *GetOptions() override { return &m_options; }
   
+  static constexpr const char *g_short_help_template  = 
+      "Delete an existing %s for a type.";
+
+  static constexpr const char *g_long_help_template =  
+      "Delete an existing %s for a type.  Unless you specify a "
+      "specific category or all categories, only the "
+      "'default' category is searched.  The names must be exactly as "
+      "shown in the 'type %s list' output";
+
 public:
   CommandObjectTypeFormatterDelete(CommandInterpreter &interpreter,
-                                   uint32_t formatter_kind_mask,
-                                   const char *name, const char *help)
-      : CommandObjectParsed(interpreter, name, help, nullptr),
-        m_formatter_kind_mask(formatter_kind_mask) {
+                                   FormatCategoryItem formatter_kind)
+      : CommandObjectParsed(interpreter, 
+                            FormatCategoryToString(formatter_kind, false)),
+                            m_formatter_kind(formatter_kind) {
     CommandArgumentEntry type_arg;
     CommandArgumentData type_style_arg;
 
     type_style_arg.arg_type = eArgTypeName;
     type_style_arg.arg_repetition = eArgRepeatPlain;
 
     type_arg.push_back(type_style_arg);
 
     m_arguments.push_back(type_arg);
+    
+    const char *kind = FormatCategoryToString(formatter_kind, true);
+    const char *short_kind = FormatCategoryToString(formatter_kind, false);
+      
+    StreamString s;
+    s.Printf(g_short_help_template, kind);
+    SetHelp(s.GetData());
+    s.Clear();
+    s.Printf(g_long_help_template, kind, short_kind);
+    SetHelpLong(s.GetData());
+    s.Clear();
+    s.Printf("type %s delete", short_kind);
+    SetCommandName(s.GetData());
   }
 
   ~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) {
-          category_sp->AutoComplete(request, m_formatter_kind_mask);
+          category_sp->AutoComplete(request, m_formatter_kind);
           return true;
         });
   }
 
 protected:
   virtual bool FormatterSpecificDeletion(ConstString typeCS) { return false; }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (!typeCS) {
       result.AppendError("empty typenames not allowed");
       return false;
     }
 
     if (m_options.m_delete_all) {
       DataVisualization::Categories::ForEach(
           [this, typeCS](const lldb::TypeCategoryImplSP &category_sp) -> bool {
-            category_sp->Delete(typeCS, m_formatter_kind_mask);
+            category_sp->Delete(typeCS, m_formatter_kind);
             return true;
           });
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
       return result.Succeeded();
     }
 
     bool delete_category = false;
     bool extra_deletion = false;
 
     if (m_options.m_language != lldb::eLanguageTypeUnknown) {
       lldb::TypeCategoryImplSP category;
       DataVisualization::Categories::GetCategory(m_options.m_language,
                                                  category);
       if (category)
-        delete_category = category->Delete(typeCS, m_formatter_kind_mask);
+        delete_category = category->Delete(typeCS, m_formatter_kind);
       extra_deletion = FormatterSpecificDeletion(typeCS);
     } else {
       lldb::TypeCategoryImplSP category;
       DataVisualization::Categories::GetCategory(
           ConstString(m_options.m_category.c_str()), category);
       if (category)
-        delete_category = category->Delete(typeCS, m_formatter_kind_mask);
+        delete_category = category->Delete(typeCS, m_formatter_kind);
       extra_deletion = FormatterSpecificDeletion(typeCS);
     }
 
     if (delete_category || extra_deletion) {
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
       return result.Succeeded();
     } else {
       result.AppendErrorWithFormat("no custom formatter for %s.\n", typeA);
       return false;
     }
   }
 };
 
 #define LLDB_OPTIONS_type_formatter_clear
 #include "CommandOptions.inc"
 
 class CommandObjectTypeFormatterClear : public CommandObjectParsed {
 private:
   class CommandOptions : public Options {
   public:
     CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::ArrayRef(g_type_formatter_clear_options);
     }
 
     // Instance variables to hold the values for command options.
     bool m_delete_all;
   };
 
   CommandOptions m_options;
-  uint32_t m_formatter_kind_mask;
+  FormatCategoryItem m_formatter_kind;
 
   Options *GetOptions() override { return &m_options; }
 
 public:
   CommandObjectTypeFormatterClear(CommandInterpreter &interpreter,
-                                  uint32_t formatter_kind_mask,
+                                  FormatCategoryItem formatter_kind,
                                   const char *name, const char *help)
       : CommandObjectParsed(interpreter, name, help, nullptr),
-        m_formatter_kind_mask(formatter_kind_mask) {
+        m_formatter_kind(formatter_kind) {
     CommandArgumentData category_arg{eArgTypeName, eArgRepeatOptional};
     m_arguments.push_back({category_arg});
   }
 
   ~CommandObjectTypeFormatterClear() override = default;
 
 protected:
   virtual void FormatterSpecificDeletion() {}
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (m_options.m_delete_all) {
       DataVisualization::Categories::ForEach(
           [this](const TypeCategoryImplSP &category_sp) -> bool {
-            category_sp->Clear(m_formatter_kind_mask);
+            category_sp->Clear(m_formatter_kind);
             return true;
           });
     } else {
       lldb::TypeCategoryImplSP category;
       if (command.GetArgumentCount() > 0) {
         const char *cat_name = command.GetArgumentAtIndex(0);
         ConstString cat_nameCS(cat_name);
         DataVisualization::Categories::GetCategory(cat_nameCS, category);
       } else {
         DataVisualization::Categories::GetCategory(ConstString(nullptr),
                                                    category);
       }
-      category->Clear(m_formatter_kind_mask);
+      category->Clear(m_formatter_kind);
     }
 
     FormatterSpecificDeletion();
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 };
 
 // CommandObjectTypeFormatDelete
 
 class CommandObjectTypeFormatDelete : public CommandObjectTypeFormatterDelete {
 public:
   CommandObjectTypeFormatDelete(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterDelete(
-            interpreter, eFormatCategoryItemFormat, "type format delete",
-            "Delete an existing formatting style for a type.") {}
+            interpreter, eFormatCategoryItemFormat) {}
 
   ~CommandObjectTypeFormatDelete() override = default;
 };
 
 // CommandObjectTypeFormatClear
 
 class CommandObjectTypeFormatClear : public CommandObjectTypeFormatterClear {
 public:

 }
 
 // CommandObjectTypeSummaryDelete
 
 class CommandObjectTypeSummaryDelete : public CommandObjectTypeFormatterDelete {
 public:
   CommandObjectTypeSummaryDelete(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterDelete(
-            interpreter, eFormatCategoryItemSummary, "type summary delete",
-            "Delete an existing summary for a type.") {}
+            interpreter, eFormatCategoryItemSummary) {}
 
   ~CommandObjectTypeSummaryDelete() override = default;
 
 protected:
   bool FormatterSpecificDeletion(ConstString typeCS) override {
     if (m_options.m_language != lldb::eLanguageTypeUnknown)
       return false;
     return DataVisualization::NamedSummaryFormats::Delete(typeCS);

 #endif
 
 // CommandObjectTypeFilterDelete
 
 class CommandObjectTypeFilterDelete : public CommandObjectTypeFormatterDelete {
 public:
   CommandObjectTypeFilterDelete(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterDelete(
-            interpreter, eFormatCategoryItemFilter, "type filter delete",
-            "Delete an existing filter for a type.") {}
+            interpreter, eFormatCategoryItemFilter) {}
 
   ~CommandObjectTypeFilterDelete() override = default;
 };
 
 #if LLDB_ENABLE_PYTHON
 
 // CommandObjectTypeSynthDelete
 
 class CommandObjectTypeSynthDelete : public CommandObjectTypeFormatterDelete {
 public:
   CommandObjectTypeSynthDelete(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterDelete(
-            interpreter, eFormatCategoryItemSynth, "type synthetic delete",
-            "Delete an existing synthetic provider for a type.") {}
+            interpreter, eFormatCategoryItemSynth) {}
 
   ~CommandObjectTypeSynthDelete() override = default;
 };
 
 #endif
 
 // CommandObjectTypeFilterClear