[lldb/Interpreter] Make OptionGroupPythonClassWithDict options non-required

[mib]

Summary

When using OptionGroupPythonClassWithDict options in an OptionGroup
with other Options, it can happen that the combinaison of some options
of each group makes the command invalid.

To solve that issue, this patch adds a bitmask argument to the
OptionGroupPythonClassWithDict constuctor that is used to mark each
option as required (or not).

If the required_options bitmask isn't passed to the constructor, the
class will keep its default behaviour, making the --script-class and
--python-function options required.

rdar://65508855

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

Fix header guard length.

[JDevlieghere]

lldb/include/lldb/Interpreter/OptionGroupPythonClassWithDict.h

12

We generally include system headers after project headers.

67

I don't mind the bitset but we have a Flags utility that seems like a good fit for this.

[mib]

Replace std::bitset by lldb_private::Flags as suggested by @JDevlieghere

[JDevlieghere]

LGTM

lldb/include/lldb/Interpreter/OptionGroupPythonClassWithDict.h

-//===-- OptionGroupPythonClassWithDict.h -------------------------------------*- C++ -*-===//
+//===-- OptionGroupPythonClassWithDict.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 LLDB_INTERPRETER_OPTIONGROUPPYTHONCLASSWITHDICT_H
 #define LLDB_INTERPRETER_OPTIONGROUPPYTHONCLASSWITHDICT_H
 
-#include "lldb/lldb-types.h"
 #include "lldb/Interpreter/Options.h"
+#include "lldb/Utility/Flags.h"
 #include "lldb/Utility/StructuredData.h"
+#include "lldb/lldb-types.h"
 
 namespace lldb_private {
 
 // Use this Option group if you have a python class that implements some
 // Python extension point, and you pass a SBStructuredData to the class 
 // __init__ method.  
 // class_option specifies the class name
 // the key and value options are read in in pairs, and a 
 // StructuredData::Dictionary is constructed with those pairs.
 class OptionGroupPythonClassWithDict : public OptionGroup {
 public:
-  OptionGroupPythonClassWithDict(const char *class_use,
-                                 bool is_class = true,
-                                 int class_option = 'C',
-                                 int key_option = 'k', 
-                                 int value_option = 'v');
-                      
+  enum OptionKind {
+    eScriptClass    = 1 << 0,
+    eDictKey        = 1 << 1,
+    eDictValue      = 1 << 2,
+    ePythonFunction = 1 << 3,
+    eAllOptions     = (eScriptClass | eDictKey | eDictValue | ePythonFunction)
+  };
+
+  OptionGroupPythonClassWithDict(const char *class_use, bool is_class = true,
+                                 int class_option = 'C', int key_option = 'k',
+                                 int value_option = 'v',
+                                 uint16_t required_options = eScriptClass |
+                                                             ePythonFunction);
   ~OptionGroupPythonClassWithDict() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::ArrayRef<OptionDefinition>(m_option_definition);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                         ExecutionContext *execution_context) override;

 
 protected:
   std::string m_name;
   std::string m_current_key;
   StructuredData::DictionarySP m_dict_sp;
   std::string m_class_usage_text, m_key_usage_text, m_value_usage_text;
   bool m_is_class;
   OptionDefinition m_option_definition[4];
+  Flags m_required_options;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONGROUPPYTHONCLASSWITHDICT_H

lldb/source/Interpreter/OptionGroupPythonClassWithDict.cpp

 //===-- OptionGroupPythonClassWithDict.cpp --------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionGroupPythonClassWithDict.h"
 
 #include "lldb/Host/OptionParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-OptionGroupPythonClassWithDict::OptionGroupPythonClassWithDict
-    (const char *class_use,
-     bool is_class,
-     int class_option,
-     int key_option, 
-     int value_option) : m_is_class(is_class) {
+OptionGroupPythonClassWithDict::OptionGroupPythonClassWithDict(
+    const char *class_use, bool is_class, int class_option, int key_option,
+    int value_option, uint16_t required_options)
+    : m_is_class(is_class), m_required_options(required_options) {
   m_key_usage_text.assign("The key for a key/value pair passed to the "
                           "implementation of a ");
   m_key_usage_text.append(class_use);
   m_key_usage_text.append(".  Pairs can be specified more than once.");
   
   m_value_usage_text.assign("The value for the previous key in the pair passed "
                             "to the implementation of a ");
   m_value_usage_text.append(class_use);
   m_value_usage_text.append(".  Pairs can be specified more than once.");
   
   m_class_usage_text.assign("The name of the ");
   m_class_usage_text.append(m_is_class ? "class" : "function");
   m_class_usage_text.append(" that will manage a ");
   m_class_usage_text.append(class_use);
   m_class_usage_text.append(".");
   
   m_option_definition[0].usage_mask = LLDB_OPT_SET_1;
-  m_option_definition[0].required = true;
+  m_option_definition[0].required = m_required_options.Test(eScriptClass);
   m_option_definition[0].long_option = "script-class";
   m_option_definition[0].short_option = class_option;
   m_option_definition[0].validator = nullptr;
   m_option_definition[0].option_has_arg = OptionParser::eRequiredArgument;
   m_option_definition[0].enum_values = {};
   m_option_definition[0].completion_type = 0;
   m_option_definition[0].argument_type = eArgTypePythonClass;
   m_option_definition[0].usage_text = m_class_usage_text.data();
 
   m_option_definition[1].usage_mask = LLDB_OPT_SET_2;
-  m_option_definition[1].required = false;
+  m_option_definition[1].required = m_required_options.Test(eDictKey);
   m_option_definition[1].long_option = "structured-data-key";
   m_option_definition[1].short_option = key_option;
   m_option_definition[1].validator = nullptr;
   m_option_definition[1].option_has_arg = OptionParser::eRequiredArgument;
   m_option_definition[1].enum_values = {};
   m_option_definition[1].completion_type = 0;
   m_option_definition[1].argument_type = eArgTypeNone;
   m_option_definition[1].usage_text = m_key_usage_text.data();
 
   m_option_definition[2].usage_mask = LLDB_OPT_SET_2;
-  m_option_definition[2].required = false;
+  m_option_definition[2].required = m_required_options.Test(eDictValue);
   m_option_definition[2].long_option = "structured-data-value";
   m_option_definition[2].short_option = value_option;
   m_option_definition[2].validator = nullptr;
   m_option_definition[2].option_has_arg = OptionParser::eRequiredArgument;
   m_option_definition[2].enum_values = {};
   m_option_definition[2].completion_type = 0;
   m_option_definition[2].argument_type = eArgTypeNone;
   m_option_definition[2].usage_text = m_value_usage_text.data();
   
   m_option_definition[3].usage_mask = LLDB_OPT_SET_3;
-  m_option_definition[3].required = true;
+  m_option_definition[3].required = m_required_options.Test(ePythonFunction);
   m_option_definition[3].long_option = "python-function";
   m_option_definition[3].short_option = class_option;
   m_option_definition[3].validator = nullptr;
   m_option_definition[3].option_has_arg = OptionParser::eRequiredArgument;
   m_option_definition[3].enum_values = {};
   m_option_definition[3].completion_type = 0;
   m_option_definition[3].argument_type = eArgTypePythonFunction;
   m_option_definition[3].usage_text = m_class_usage_text.data();
-
 }
 
 Status OptionGroupPythonClassWithDict::SetOptionValue(
     uint32_t option_idx,
     llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
   switch (option_idx) {