[lldb] Preserve type sugar when using SBValue::Dereference on C++ references

[teemperor]

Summary

When checking for type properties we usually want to strip all kind of type sugar from
the type. For example, sugar like Clang's ElaboratedType or typedefs rarely influence
the fundamental behaviour of a type such as its byte size.

However we always need to preserve type sugar for everything else as it does matter
for users that their variable of type size_t instead of unsigned long for example.

This patch fixes one such bug when trying to use the SBValue API to dereference a
a type.

[werat]

Thanks for fixing this!

[shafik]

Nice fix!

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

case clang::Type::Pointer: {
     }
     break;
   }
 
   case clang::Type::LValueReference:
   case clang::Type::RValueReference:
     if (idx_is_valid) {
       const clang::ReferenceType *reference_type =
-          llvm::cast<clang::ReferenceType>(parent_qual_type.getTypePtr());
+          llvm::cast<clang::ReferenceType>(GetQualType(type).getTypePtr());
       CompilerType pointee_clang_type =
           GetType(reference_type->getPointeeType());
       if (transparent_pointers && pointee_clang_type.IsAggregateType()) {
         child_is_deref_of_parent = false;
         bool tmp_child_is_deref_of_parent = false;
         return pointee_clang_type.GetChildCompilerTypeAtIndex(
             exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
             ignore_array_bounds, child_name, child_byte_size, child_byte_offset,

lldb/test/API/lang/cpp/dereferencing_references/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/lang/cpp/dereferencing_references/TestCPPDereferencingReferences.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test(self):
+        """Tests deferencing lvalue/rvalue references via LLDB's builtin type system."""
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.cpp"))
+
+        # Take an lvalue reference and call `Dereference` on the SBValue.
+        # The result should be `TTT` (and *not* for example the underlying type
+        # 'int').
+        lref_val = self.expect_var_path("l_ref", type="TTT &")
+        self.assertEqual(lref_val.Dereference().GetType().GetName(), "TTT")
+
+        # Same as above for rvalue references.
+        rref_val = self.expect_var_path("r_ref", type="TTT &&")
+        self.assertEqual(rref_val.Dereference().GetType().GetName(), "TTT")

lldb/test/API/lang/cpp/dereferencing_references/main.cpp

+typedef int TTT;
+
+int main() {
+  int i = 0;
+  TTT &l_ref = i;
+  TTT &&r_ref = static_cast<TTT &&>(i);
+  return l_ref; // break here
+}