Merge pull request llvm#8472 from augusto2112/cp-257d4606bc

[lldb] Support frame variable for generic types in embedded Swift

Author: augusto2112

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserSwiftDescriptorFinder.cpp

@@ -32,6 +32,29 @@ using namespace lldb_private;
 using namespace lldb_private::dwarf;
 using namespace lldb_private::plugin::dwarf;
 
+/// Given a die to a substituted generic Swift type, return the analogous
+/// unsubstituted version.
+///
+/// Given a generic type (for example, a generic Pair), the compiler will emit
+/// full debug information for the unsubstituted type (Pair<T, U>), and opaque
+/// debug information for each every specialization (for example, Pair<Int,
+/// Double>), with a link back to the unsubstituted type. When looking up one of
+/// the specialized generics, return the unsubstituted version instead.
+static std::optional<std::pair<CompilerType, DWARFDIE>>
+findUnsubstitutedGenericTypeAndDie(TypeSystemSwiftTypeRef &ts,
+                                   const DWARFDIE &die) {
+  auto specified_die =
+      die.GetAttributeValueAsReferenceDIE(llvm::dwarf::DW_AT_specification);
+  if (!specified_die)
+    return {};
+
+  const auto *mangled_name = specified_die.GetAttributeValueAsString(
+      llvm::dwarf::DW_AT_linkage_name, nullptr);
+  assert(mangled_name);
+  auto specified_type =
+      ts.GetTypeFromMangledTypename(ConstString(mangled_name));
+  return {{specified_type, specified_die}};
+}
 /// Given a type system and a typeref, return the compiler type and die of the
 /// type that matches that mangled name, looking up the in the type system's
 /// module's debug information.
@@ -62,6 +85,10 @@ getTypeAndDie(TypeSystemSwiftTypeRef &ts,
     return {};
   }
   auto die = dwarf->GetDIE(lldb_type->GetID());
+
+  if (auto unsubstituted_pair = findUnsubstitutedGenericTypeAndDie(ts, die))
+    return unsubstituted_pair;
+
   return {{type, die}};
 }
 

lldb/test/API/lang/swift/embedded/frame_variable/TestSwiftEmbeddedFrameVariable.py

@@ -129,3 +129,61 @@ def test(self):
                 "subSubField = (field = 4.2000000000000002)",
             ],
         )
+
+        self.expect(
+            "frame variable gsp",
+            substrs=[
+                "GenericStructPair<Int, Double>) gsp =",
+                "(t = 42, u = 94.299999999999997)",
+            ],
+        )
+
+        self.expect(
+            "frame variable gsp2",
+            substrs=[
+                "a.GenericStructPair<a.Sup, a.B>) gsp2 = {",
+                "t = ",
+                "(supField = 42)",
+                "u = {",
+                "a = (field = 4.2000000000000002)",
+                "b = 123456",
+            ],
+        )
+
+        self.expect(
+            "frame variable gsp3",
+            substrs=[
+                "(a.GenericStructPair<a.BigFullMultipayloadEnum,",
+                "a.SmallMultipayloadEnum>) gsp3 = {",
+                "t = one {",
+                "one = (0 = 209, 1 = 315)",
+                "u = two {",
+            ],
+        )
+
+        self.expect(
+            "frame variable gcp",
+            substrs=[
+                "GenericClassPair<Double, Int>) gcp =",
+                "(t = 43.799999999999997, u = 9348)",
+            ],
+        )
+
+        self.expect(
+            "frame variable either",
+            substrs=["(a.Either<Int, Double>) either =", "left (left = 1234)"],
+        )
+
+        self.expect(
+            "frame variable either2",
+            substrs=[
+                "(a.Either<a.Sup, a.GenericStructPair<a.BigFullMultipayloadEnum,",
+                "a.SmallMultipayloadEnum>>)",
+                "either2 = right {",
+                "right = {",
+                "t = one {",
+                "one = (0 = 209, 1 = 315)",
+                "u = two {",
+                "two = one",
+            ],
+        )

lldb/test/API/lang/swift/embedded/frame_variable/main.swift

@@ -62,6 +62,27 @@ class SubSub: Sub {
   var subSubField = A()
 }
 
+
+struct GenericStructPair<T, U> {
+  let t: T
+  let u: U
+}
+
+class GenericClassPair<T, U> {
+  let t: T
+  let u: U
+
+  init(t: T, u: U) {
+    self.t = t
+    self.u = u
+  }
+}
+
+enum Either<Left, Right> {
+  case left(Left)
+  case right(Right)
+}
+
 let varB = B()
 let tuple = (A(), B())
 let trivial = TrivialEnum.theCase
@@ -85,6 +106,12 @@ let sup = Sup()
 let sub = Sub()
 let subSub = SubSub()
 let sup2: Sup = SubSub()
+let gsp = GenericStructPair(t: 42, u: 94.3)
+let gsp2 = GenericStructPair(t: Sup(), u: B())
+let gsp3 = GenericStructPair(t: bigFullMultipayloadEnum1, u: smallMultipayloadEnum2)
+let gcp = GenericClassPair(t: 43.8, u: 9348)
+let either = Either<Int, Double>.left(1234)
+let either2 = Either<Sup, _>.right(gsp3)
 
 // Dummy statement to set breakpoint print can't be used in embedded Swift for now.
 let dummy = A() // break here