[lldb] Skip check for conflicting filter/synth when adding a new regex.

[jgorbe]

Summary

When adding a new synthetic child provider, we check for an existing
conflicting filter in the same category (and vice versa). This is done
by trying to match the new type name against registered formatters.

However, the new type name we're registered can also be a regex
(type synth add -x), and in this case the conflict check is just
wrong: it will try to match the new regex as if it was a type name,
against previously registered regexes.

See https://github.com/llvm/llvm-project/issues/57947 for a longer
explanation with concrete examples of incorrect behavior.

[jgorbe]

Added a couple of test cases to TestDataFormatterPythonSynth.py.

[labath]

The current behavior is clearly not useful, but I don't have any context to be able to determine whether there's something else that can be done about that. @jingham might have it.

[jgorbe]

Ping? If anyone has other suggestions for reviewers I'd appreciate them.

[labath]

Let's just skip this check. Though it might be fun to implement an emptyness-of-intersection check for two regular expressions, that's: a) overkill; b) impossible if you include backreferences.

lldb/source/Commands/CommandObjectType.cpp

bool CommandObjectTypeSynthAdd::AddSynth(ConstString type_name,
   DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()),
                                              category);
 
   if (type == eRegularSynth) {
     if (FixArrayTypeNameWithRegex(type_name))
       type = eRegexSynth;
   }
 
+  // Only check for conflicting filters in the same category if `type_name` is
+  // an actual type name. Matching a regex string against registered regexes
+  // doesn't work.
+  if (type == eRegularSynth) {
     if (category->AnyMatches(type_name, eFormatCategoryItemFilter, false)) {
       if (error)
         error->SetErrorStringWithFormat("cannot add synthetic for type %s when "
                                         "filter is defined in same category!",
                                         type_name.AsCString());
       return false;
     }
+  }
 
   if (type == eRegexSynth) {
     RegularExpression typeRX(type_name.GetStringRef());
     if (!typeRX.IsValid()) {
       if (error)
         error->SetErrorString(
             "regex format error (maybe this is not really a regex?)");
       return false;
bool AddFilter(ConstString type_name, TypeFilterImplSP entry,
     DataVisualization::Categories::GetCategory(
         ConstString(category_name.c_str()), category);
 
     if (type == eRegularFilter) {
       if (FixArrayTypeNameWithRegex(type_name))
         type = eRegexFilter;
     }
 
+    // Only check for conflicting synthetic child providers in the same category
+    // if `type_name` is an actual type name. Matching a regex string against
+    // registered regexes doesn't work.
+    if (type == eRegularFilter) {
       if (category->AnyMatches(type_name, eFormatCategoryItemSynth, false)) {
         if (error)
           error->SetErrorStringWithFormat("cannot add filter for type %s when "
                                           "synthetic is defined in same "
                                           "category!",
                                           type_name.AsCString());
         return false;
       }
+    }
 
     if (type == eRegexFilter) {
       RegularExpression typeRX(type_name.GetStringRef());
       if (!typeRX.IsValid()) {
         if (error)
           error->SetErrorString(
               "regex format error (maybe this is not really a regex?)");
         return false;

lldb/test/API/functionalities/data-formatter/data-formatter-python-synth/TestDataFormatterPythonSynth.py

def data_formatter_commands(self):
         self.expect("frame variable f00_1",
                     substrs=['a = 280',
                              'b = 2',
                              'j = 18'])
 
         self.expect("frame variable f00_1", matching=False,
                     substrs=['fake_a = '])
 
+        # check that we don't feed a regex into another regex when checking for
+        # existing conflicting synth/filters. The two following expressions
+        # accept different types: one will accept types that look like an array
+        # of MyType, the other will accept types that contain "MyType1" or
+        # "MyType2". But the second regex looks like an array of MyType, so
+        # lldb used to incorrectly reject it.
+        self.runCmd(r'type synth add -l fooSynthProvider -x "^MyType\[[0-9]+]$"')
+        self.runCmd(r'type filter add --child a -x "MyType[12]"')
+
+        # Same, but adding the filter first to verify the check when doing
+        # `type synth add`. We need to delete the synth from the previous test
+        # first.
+        self.runCmd(r'type synth delete "^MyType\[[0-9]+]$"')
+        self.runCmd(r'type filter add --child a -x "^MyType\[[0-9]+]$"')
+        self.runCmd(r'type synth add -l fooSynthProvider -x "MyType[12]"')
+
     def rdar10960550_formatter_commands(self):
         """Test that synthetic children persist stoppoints."""
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         # The second breakpoint is on a multi-line expression, so the comment
         # can't be on the right line...
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line2, num_expected_locations=1, loc_exact=False)