[lldb] Wire up reflection support for Builtin.FixedArray

Author: adrian-prantl

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp

@@ -833,6 +833,22 @@ SwiftLanguageRuntime::GetNumChildren(CompilerType type,
                                    type.GetMangledTypeName().GetString());
   }
 
+  if (auto *ati = llvm::dyn_cast<swift::reflection::ArrayTypeInfo>(ti)) {
+    LLDB_LOG(GetLog(LLDBLog::Types), "{0}: ArrayTypeInfo()",
+             type.GetMangledTypeName().GetCString());
+    auto *el_ti = ati->getElementTypeInfo();
+    if (!el_ti)
+      return llvm::createStringError("Array without element type info: " +
+                                     type.GetMangledTypeName().GetString());
+    // We could also get the value out of the mangled type name, but
+    // this is cheaper.
+    unsigned stride = el_ti->getStride();
+    if (!stride)
+      return llvm::createStringError("Array without element stride: " +
+                                     type.GetMangledTypeName().GetString());
+    return ati->getSize() / stride;
+  }
+
   LogUnimplementedTypeKind(__FUNCTION__, type);
   return llvm::createStringError("GetNumChildren unimplemented for type " +
                                  type.GetMangledTypeName().GetString());
@@ -1451,6 +1467,40 @@ llvm::Expected<CompilerType> SwiftLanguageRuntime::GetChildCompilerTypeAtIndex(
                                    "is out of bounds (" + llvm::Twine(i - 1) +
                                    ")");
   }
+  // Fixed array.
+  if (auto *ati = llvm::dyn_cast<swift::reflection::ArrayTypeInfo>(ti)) {
+    LLDB_LOG(GetLog(LLDBLog::Types), "{0}: ArrayTypeInfo()",
+             type.GetMangledTypeName().GetCString());
+    auto *el_ti = ati->getElementTypeInfo();
+    if (!el_ti)
+      return llvm::createStringError("array without element type info: " +
+                                     type.GetMangledTypeName().GetString());
+    child_name.clear();
+    llvm::raw_string_ostream(child_name) << idx;
+    child_byte_size = el_ti->getSize();
+    child_byte_offset = el_ti->getStride() * idx;
+    if (!ignore_array_bounds &&
+        (int64_t)child_byte_offset > (int64_t)ati->getSize())
+      return llvm::createStringError("array index out of bounds");
+
+    child_bitfield_bit_size = 0;
+    child_bitfield_bit_offset = 0;
+    child_is_base_class = false;
+    child_is_deref_of_parent = false;
+    language_flags = 0;
+
+    swift::Demangle::Demangler dem;
+    swift::Demangle::NodePointer global =
+        dem.demangleSymbol(type.GetMangledTypeName().GetStringRef());
+    using Kind = Node::Kind;
+    auto *dem_array_type = swift_demangle::ChildAtPath(
+        global, {Kind::TypeMangling, Kind::Type, Kind::BuiltinFixedArray});
+    if (!dem_array_type || dem_array_type->getNumChildren() != 2)
+      return llvm::createStringError("Expected fixed array, but found: " +
+                                     type.GetMangledTypeName().GetString());
+    return ts->RemangleAsType(dem, dem_array_type->getChild(1),
+                              ts->GetManglingFlavor());
+  }
   if (llvm::dyn_cast_or_null<swift::reflection::BuiltinTypeInfo>(ti)) {
     // Clang enums have an artificial rawValue property. We could
     // consider handling them here, but

lldb/test/API/lang/swift/value_generics/TestSwiftValueGenerics.py

@@ -10,12 +10,14 @@ class TestSwiftVariadicGenerics(TestBase):
     def test(self):
         self.build()
 
-        target,  process, _, _ = lldbutil.run_to_source_breakpoint(
+        target,  process, thread, _ = lldbutil.run_to_source_breakpoint(
             self, "break here", lldb.SBFileSpec('main.swift'))
-        self.expect('log enable lldb types')
-        self.expect("frame variable v",
+        self.expect("frame variable ints",
                     substrs=["a.Vector<4, Int>", "storage",
-                             "0", "0",
-                             "1", "1",
-                             "2", "2",
-                             "3", "3"])
+                             "0", "1", "2", "3"])
+        self.expect("frame variable bools",
+                    substrs=["a.Vector<2, Bool>", "storage",
+                             "false", "true"])
+        self.expect("frame variable structs",
+                    substrs=["a.Vector<2, S>", "storage",
+                             "i", "1", "j", "2", "i", "3", "j", "4"])

lldb/test/API/lang/swift/value_generics/main.swift

@@ -37,12 +37,20 @@ extension Vector: Copyable where Element: Copyable {
 extension Vector: BitwiseCopyable where Element: BitwiseCopyable {}
 
 func main() {
-    var v = Vector<4, Int>(repeating: 0)
-    v[0] = 0
-    v[1] = 1
-    v[2] = 2
-    v[3] = 3
+    var ints = Vector<4, Int>(repeating: 0)
+    ints[0] = 0
+    ints[1] = 1
+    ints[2] = 2
+    ints[3] = 3
+    var bools = Vector<2, Bool>(repeating: false)
+    bools[0] = false
+    bools[1] = true
 
-    print(v)  // break here
+    struct S { let i : Int; let j : Int };
+    var structs = Vector<2, S>(repeating: S(i: 1, j: 2))
+    structs[0] = S(i: 1, j: 2)
+    structs[1] = S(i: 3, j: 4)
+    
+    print("\(ints), \(bools), \(structs)")  // break here
 }
 main()