[formatters] Add a libstdcpp formatter for multimap and unify modify tests across stdlibs

[danilashtefan]

Summary

This diff adds a data formatter for libstdcpp's multimap. Besides, it improves and unifies the tests for multimap for libcxx and libstdcpp for maintainability.

[wallace]

pretty good, just cosmetic changes and a comment update needed

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

915

Now I don't like the name of the class. Let's rename it to MakeLikeSynthProvider, and update the comments mentioning that it supports any map-like structure like map, multimap, set and multiset.

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/multimap/TestDataFormatterGenericMultiMap.py

40

nice!!

88–285

the general practice is to leave a space after each comma for readability, e.g.

self.check("ss", 3)

instead of

self.check("ss",3)

these little details matter as it help people more easily distinguish the end of each token

320

same here

[danilashtefan]

All the above specified parts are changed. Thank you!

[danilashtefan]

I thought that you misprinted the name and wanted to call the formatter MapLikeSynth provider. Please, correct me if I am wrong and I will change names accordingly

[wallace]

thanks! i'll land this now

lldb/examples/synthetic/gnu_libstdcpp.py

321

this is correct

lldb/examples/synthetic/gnu_libstdcpp.py

class StdVectorSynthProvider:
 
     def update(self):
         return self.impl.update()
 
     def has_children(self):
         return True
 
     """
-    Set and Map have the same underlying data structure,
-    therefore we can use exactly the same implementation for the formatter.
+     This formatter can be applied to all
+     map-like structures (map, multimap, set, multiset)
     """
-class StdSetOrMapSynthProvider:
+class StdMapLikeSynthProvider:
 
     def __init__(self, valobj, dict):
         logger = lldb.formatters.Logger.Logger()
         self.valobj = valobj
         self.count = None
         self.kind = "set" if "set" in valobj.GetTypeName() else "map"
         logger >> "Providing synthetic children for a " + self.kind + " named " + \
             str(valobj.GetName())

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::vector<.+>(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_synth_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::map<.+> >(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_synth_flags,
-          "lldb.formatters.cpp.gnu_libstdcpp.StdSetOrMapSynthProvider")));
+          "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::set<.+> >(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_deref_flags,
-          "lldb.formatters.cpp.gnu_libstdcpp.StdSetOrMapSynthProvider")));
+          "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
+  cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
+      RegularExpression("^std::multimap<.+> >(( )?&)?$"),
+      SyntheticChildrenSP(new ScriptedSyntheticChildren(
+          stl_deref_flags,
+          "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_synth_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
   stl_summary_flags.SetDontShowChildren(false);
   stl_summary_flags.SetSkipPointers(false);
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::bitset<.+>(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::vector<.+>(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::map<.+> >(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::set<.+> >(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
+      RegularExpression("^std::multimap<.+> >(( )?&)?$"),
+      TypeSummaryImplSP(
+          new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
+  cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator,
       "std::vector iterator synthetic children",

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/multimap/Makefile

 CXX_SOURCES := main.cpp
 
-USE_LIBCPP := 1
-
-CXXFLAGS_EXTRAS := -O0
 include Makefile.rules

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/multimap/TestDataFormatterGenericMultiMap.py

 """
 Test lldb data formatter subsystem.
 """
 
 
 
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
+USE_LIBSTDCPP = "USE_LIBSTDCPP"
+USE_LIBCPP = "USE_LIBCPP"
 
-class LibcxxMultiMapDataFormatterTestCase(TestBase):
+class GenericMultiMapDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
         self.namespace = 'std'
     
-    @add_test_categories(["libc++"])
-    def test_with_run_command(self):
+    def findVariable(self, name):
+        var = self.frame().FindVariable(name)
+        self.assertTrue(var.IsValid())
+        return var
+
+    def getVariableType(self, name):
+        var = self.findVariable(name)
+        return var.GetType().GetDisplayTypeName()
+
+    def check(self, var_name, size):
+        var = self.findVariable(var_name)
+        self.assertEqual(var.GetNumChildren(), size)
+        children = []
+        for i in range(size):
+            child = var.GetChildAtIndex(i)
+            children.append(ValueCheck(value=child.GetValue()))
+        self.expect_var_path(var_name, type=self.getVariableType(var_name), children=children)
+
+    def do_test_with_run_command(self, stdlib_type):
         """Test that that file and class static variables display correctly."""
-        self.build()
+        self.build(dictionary={stdlib_type: "1"})
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         bkpt = self.target().FindBreakpointByID(
             lldbutil.run_break_set_by_source_regexp(
                 self, "Set break point at this line."))
 
         self.runCmd("run", RUN_SUCCEEDED)
 
def do_test_with_run_command(self, stdlib_type):
         self.expect(
             'frame variable ii',
             substrs=[
                 multimap,
                 'size=2',
                 '[0] = (first = 0, second = 0)',
                 '[1] = (first = 1, second = 1)',
             ])
         
+        self.check("ii", 2)
+
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect('frame variable ii',
                     substrs=[multimap, 'size=4',
                              '[2] = ',
                              'first = 2',
                              'second = 0',
                              '[3] = ',
                              'first = 3',
                              'second = 1'])
         
+        self.check("ii", 4)
+
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect("frame variable ii",
                     substrs=[multimap, 'size=8',
                              '[5] = ',
                              'first = 5',
                              'second = 0',
                              '[7] = ',
                              'first = 7',
                              'second = 1'])
 
+        self.check("ii", 8)
+
         self.expect("p ii",
                     substrs=[multimap, 'size=8',
                              '[5] = ',
                              'first = 5',
                              'second = 0',
                              '[7] = ',
                              'first = 7',
                              'second = 1'])
 
         # check access-by-index
         self.expect("frame variable ii[0]",
                     substrs=['first = 0',
                              'second = 0'])
         self.expect("frame variable ii[3]",
                     substrs=['first =',
                              'second ='])
 
         # check that MightHaveChildren() gets it right
         self.assertTrue(
             self.frame().FindVariable("ii").MightHaveChildren(),
             "ii.MightHaveChildren() says False for non empty!")
 
         # check that the expression parser does not make use of
         # synthetic children instead of running code
         # TOT clang has a fix for this, which makes the expression command here succeed
         # since this would make the test fail or succeed depending on clang version in use
         # this is safer commented for the time being
         # self.expect("expression ii[8]", matching=False, error=True,
         #            substrs = ['1234567'])
 
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect('frame variable ii',
                     substrs=[multimap, 'size=0',
                              '{}'])
 
         self.expect('frame variable si',
                     substrs=[multimap, 'size=0',
                              '{}'])
 
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect('frame variable si',
                     substrs=[multimap, 'size=1',
                              '[0] = ',
                              'first = \"zero\"',
                              'second = 0'])
 
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect(
             "frame variable si",
             substrs=[
                 multimap,
                 'size=4',
                 '[0] = (first = "one", second = 1)',
                 '[1] = (first = "three", second = 3)',
                 '[2] = (first = "two", second = 2)',
                 '[3] = (first = "zero", second = 0)',
             ])
 
         self.expect("p si",
                     substrs=[multimap, 'size=4',
                 '[0] = (first = "one", second = 1)',
                 '[1] = (first = "three", second = 3)',
                 '[2] = (first = "two", second = 2)',
                 '[3] = (first = "zero", second = 0)',
             ])
 
         # check that MightHaveChildren() gets it right
         self.assertTrue(
             self.frame().FindVariable("si").MightHaveChildren(),
             "si.MightHaveChildren() says False for non empty!")
 
         # check access-by-index
         self.expect("frame variable si[0]",
                     substrs=['first = ', 'one',
                              'second = 1'])
 
         # check that the expression parser does not make use of
         # synthetic children instead of running code
         # TOT clang has a fix for this, which makes the expression command here succeed
         # since this would make the test fail or succeed depending on clang version in use
         # this is safer commented for the time being
         # self.expect("expression si[0]", matching=False, error=True,
         #            substrs = ['first = ', 'zero'])
 
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect('frame variable si',
                     substrs=[multimap, 'size=0',
                              '{}'])
 
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect('frame variable is',
                     substrs=[multimap, 'size=0',
                              '{}'])
 
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect(
             "frame variable is",
             substrs=[
                 multimap,
                 'size=4',
                 '[0] = (first = 1, second = "is")',
                 '[1] = (first = 2, second = "smart")',
                 '[2] = (first = 3, second = "!!!")',
                 '[3] = (first = 85, second = "goofy")',
             ])
 
         self.expect(
             "p is",
             substrs=[
                 multimap,
                 'size=4',
                 '[0] = (first = 1, second = "is")',
                 '[1] = (first = 2, second = "smart")',
                 '[2] = (first = 3, second = "!!!")',
                 '[3] = (first = 85, second = "goofy")',
             ])
 
         # check that MightHaveChildren() gets it right
         self.assertTrue(
             self.frame().FindVariable("is").MightHaveChildren(),
             "is.MightHaveChildren() says False for non empty!")
 
         # check access-by-index
         self.expect("frame variable is[0]",
                     substrs=['first = ',
                              'second ='])
 
         # check that the expression parser does not make use of
         # synthetic children instead of running code
         # TOT clang has a fix for this, which makes the expression command here succeed
         # since this would make the test fail or succeed depending on clang version in use
         # this is safer commented for the time being
         # self.expect("expression is[0]", matching=False, error=True,
         #            substrs = ['first = ', 'goofy'])
 
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect('frame variable is',
                     substrs=[multimap, 'size=0',
                              '{}'])
 
+        self.check("is", 0)
+
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect('frame variable ss',
                     substrs=[multimap, 'size=0',
                              '{}'])
 
+        self.check("ss", 0)
+
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect(
             "frame variable ss",
             substrs=[
                 multimap,
                 'size=3',
                 '[0] = (first = "casa", second = "house")',
                 '[1] = (first = "ciao", second = "hello")',
                 '[2] = (first = "gatto", second = "cat")',
             ])
 
+        self.check("ss", 3)
+
         self.expect(
             "p ss",
             substrs=[
                 multimap,
                 'size=3',
                 '[0] = (first = "casa", second = "house")',
                 '[1] = (first = "ciao", second = "hello")',
                 '[2] = (first = "gatto", second = "cat")',
def do_test_with_run_command(self, stdlib_type):
         # self.expect("expression ss[3]", matching=False, error=True,
         #            substrs = ['gatto'])
 
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect('frame variable ss',
                     substrs=[multimap, 'size=0',
                              '{}'])
+
+        self.check("ss", 0)
+
+    @add_test_categories(["libstdcxx"])
+    def test_with_run_command_libstdcpp(self):
+        self.do_test_with_run_command(USE_LIBSTDCPP)
+
+    @add_test_categories(["libc++"])
+    def test_with_run_command_libcpp(self):
+        self.do_test_with_run_command(USE_LIBCPP)
+