[llvm][utils] Support dereferencing llvm::Optional lldb formatter

[kastiglione]

Summary

Add deref support to llvm::Optional in lldbDataFormatters.py.

This creates a synthetic provider that adds dereference support, but otherwise proxies all access to the underlying value.

With this change, an optional value can be displayed by running v *someOptional, and its contents can be accessed with the arrow operator->, for example v someOpt->HasThing. This matches expressions usable from expression evaluation.

See also D97165 and D97524.

[JDevlieghere]

Awesome. Can't wait to use this.

llvm/utils/lldbDataFormatters.py

126

[teemperor]

Are the other changes in this patch just general bug-fixes or unrelated cleanup? Things like the new import or the dict rename to internal_dict ?

[kastiglione]

@teemperor I switched dict to internal_dict because more code uses internal_dict, and because variables named dict shadow the dict constructor. The dict constructor isn't used, but I think it's better to avoid shadowing it.

llvm/utils/lldbDataFormatters.py

141

@teemperor this is why the import lldb is needed

[kastiglione]

fix docstring

[teemperor]

LGTM, but please land the renames for dict in their own NFC commit (no need to open a review for that obviously)

llvm/utils/lldbDataFormatters.py

141

Thanks, missed that use

[kastiglione]

back out dict renames

[kastiglione]

internal_dict renames done in 8d1b6afcea6c30db7728d966d9281ab373eaa9e1

[kastiglione]

llvm/utils/lldbDataFormatters.py

135

oops this was an innocuous off by one (it still worked), I removed the +1 in a01a406bba8ac624a876f8d5720e1d4949a5b0fa

llvm/utils/lldbDataFormatters.py

 """
 LLDB Formatters for LLVM data types.
 
 Load into LLDB with 'command script import /path/to/lldbDataFormatters.py'
 """
 
+import lldb
+
 def __lldb_init_module(debugger, internal_dict):
     debugger.HandleCommand('type category define -e llvm -l c++')
     debugger.HandleCommand('type synthetic add -w llvm '
                            '-l lldbDataFormatters.SmallVectorSynthProvider '
                            '-x "^llvm::SmallVectorImpl<.+>$"')
     debugger.HandleCommand('type synthetic add -w llvm '
                            '-l lldbDataFormatters.SmallVectorSynthProvider '
                            '-x "^llvm::SmallVector<.+,.+>$"')
     debugger.HandleCommand('type synthetic add -w llvm '
                            '-l lldbDataFormatters.ArrayRefSynthProvider '
                            '-x "^llvm::ArrayRef<.+>$"')
+    debugger.HandleCommand('type synthetic add -w llvm '
+                           '-l lldbDataFormatters.OptionalSynthProvider '
+                           '-x "^llvm::Optional<.+>$"')
     debugger.HandleCommand('type summary add -w llvm '
                            '-F lldbDataFormatters.OptionalSummaryProvider '
                            '-x "^llvm::Optional<.+>$"')
     debugger.HandleCommand('type summary add -w llvm '
                            '-F lldbDataFormatters.SmallStringSummaryProvider '
                            '-x "^llvm::SmallString<.+>$"')
     debugger.HandleCommand('type summary add -w llvm '
                            '-F lldbDataFormatters.StringRefSummaryProvider '
                            '-x "^llvm::StringRef$"')
     debugger.HandleCommand('type summary add -w llvm '
                            '-F lldbDataFormatters.ConstStringSummaryProvider '
                            '-x "^lldb_private::ConstString$"')
 
 # Pretty printer for llvm::SmallVector/llvm::SmallVectorImpl
 class SmallVectorSynthProvider:
-    def __init__(self, valobj, dict):
+    def __init__(self, valobj, internal_dict):
         self.valobj = valobj;
         self.update() # initialize this provider
 
     def num_children(self):
         return self.size.GetValueAsUnsigned(0)
 
     def get_child_index(self, name):
         try:
def update(self):
             the_type = the_type.GetDereferencedType()
 
         self.data_type = the_type.GetTemplateArgumentType(0)
         self.type_size = self.data_type.GetByteSize()
         assert self.type_size != 0
 
 class ArrayRefSynthProvider:
     """ Provider for llvm::ArrayRef """
-    def __init__(self, valobj, dict):
+    def __init__(self, valobj, internal_dict):
         self.valobj = valobj;
         self.update() # initialize this provider
 
     def num_children(self):
         return self.length
 
     def get_child_index(self, name):
         try:
class ArrayRefSynthProvider:
     def update(self):
         self.data = self.valobj.GetChildMemberWithName('Data')
         length_obj = self.valobj.GetChildMemberWithName('Length')
         self.length = length_obj.GetValueAsUnsigned(0)
         self.data_type = self.data.GetType().GetPointeeType()
         self.type_size = self.data_type.GetByteSize()
         assert self.type_size != 0
 
-def OptionalSummaryProvider(valobj, internal_dict):
+def GetOptionalValue(valobj):
     storage = valobj.GetChildMemberWithName('Storage')
     if not storage:
         storage = valobj
 
     failure = 2
     hasVal = storage.GetChildMemberWithName('hasVal').GetValueAsUnsigned(failure)
     if hasVal == failure:
         return '<could not read llvm::Optional>'
 
     if hasVal == 0:
-        return 'None'
+        return None
 
     underlying_type = storage.GetType().GetTemplateArgumentType(0)
     storage = storage.GetChildMemberWithName('value')
-    return str(storage.Cast(underlying_type))
+    return storage.Cast(underlying_type)
+
+def OptionalSummaryProvider(valobj, internal_dict):
+    return GetOptionalValue(valobj).summary
+
+class OptionalSynthProvider:
+    "Provides deref support to llvm::Optional<T>"
+    def __init__(self, valobj, internal_dict):
+        self.valobj = valobj
+
+    def num_children(self):
+        return self.valobj.num_children
+
+    def get_child_index(self, name):
+        if name == '$$dereference$$':
+            return self.valobj.num_children + 1
+        return self.valobj.GetIndexOfChildWithName(name)
+
+    def get_child_at_index(self, index):
+        if index < self.valobj.num_children:
+            return self.valobj.GetChildAtIndex(index)
+        return GetOptionalValue(self.valobj) or lldb.SBValue()
 
 def SmallStringSummaryProvider(valobj, internal_dict):
     num_elements = valobj.GetNumChildren()
     res = "\""
     for i in range(0, num_elements):
         c = valobj.GetChildAtIndex(i).GetValue()
         if c:
             res += c.strip("'")