[debugger] Pretty print String, OsString, Vec

..and OsStr. There were changes to the Rust data structure so the old
printer doesn't work.

Change-Id: I3a67404bc39d20cc80a5c0eb93f2d6712fd5920f
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/714663
Reviewed-by: Jacob Rutherford <jruthe@google.com>
Commit-Queue: Dangyi Liu <dangyi@google.com>

src/developer/debug/zxdb/expr/pretty_type_manager.cc

diff --git a/src/developer/debug/zxdb/expr/pretty_type_manager.cc b/src/developer/debug/zxdb/expr/pretty_type_manager.cc
index 1b47b57..3236e88 100644
--- a/src/developer/debug/zxdb/expr/pretty_type_manager.cc
+++ b/src/developer/debug/zxdb/expr/pretty_type_manager.cc
@@ -236,6 +236,7 @@
 void PrettyTypeManager::AddDefaultRustPrettyTypes() {
   rust_tuple_type_ = std::make_unique<PrettyRustTuple>();
 
+  // Borrowed version of Str, OsStr.
   // Rust's "&str" type won't parse as an identifier, construct an Identifier manually.
   rust_.emplace_back(IdentifierGlob(ParsedIdentifier(IdentifierQualification::kRelative,
                                                      ParsedIdentifierComponent("&str"))),
@@ -245,20 +246,40 @@
                                                                    {"len", "length"},
                                                                    {"is_empty", "length == 0"}}));
   rust_.emplace_back(
-      InternalGlob("alloc::string::String"),
-      std::make_unique<PrettyHeapString>("vec.buf.ptr.pointer as *u8", "vec.len",
-                                         GetterList{{"as_ptr", "vec.buf.ptr.pointer as *u8"},
-                                                    {"as_mut_ptr", "vec.buf.ptr.pointer as *u8"},
-                                                    {"len", "vec.len"},
-                                                    {"capacity", "vec.buf.cap"},
-                                                    {"is_empty", "vec.len == 0"}}));
-  rust_.emplace_back(InternalGlob("alloc::vec::Vec<*>"),
-                     std::make_unique<PrettyArray>("buf.ptr.pointer", "len",
-                                                   GetterList{{"as_ptr", "buf.ptr.pointer"},
-                                                              {"as_mut_ptr", "buf.ptr.pointer"},
-                                                              {"len", "len"},
-                                                              {"capacity", "buf.cap"},
-                                                              {"is_empty", "len == 0"}}));
+      IdentifierGlob(ParsedIdentifier(IdentifierQualification::kRelative,
+                                      ParsedIdentifierComponent("&std::ffi::os_str::OsStr"))),
+      std::make_unique<PrettyHeapString>("data_ptr", "length",
+                                         GetterList{{"as_ptr", "data_ptr"},
+                                                    {"as_mut_ptr", "data_ptr"},
+                                                    {"len", "length"},
+                                                    {"is_empty", "length == 0"}}));
+  // TODO(fxbug.dev/79506): Support Rust slices.
+
+  // Owned version of String, OsString and Vec.
+  rust_.emplace_back(InternalGlob("alloc::string::String"),
+                     std::make_unique<PrettyHeapString>(
+                         "vec.buf.ptr.pointer.pointer as *u8", "vec.len",
+                         GetterList{{"as_ptr", "vec.buf.ptr.pointer.pointer as *u8"},
+                                    {"as_mut_ptr", "vec.buf.ptr.pointer.pointer as *u8"},
+                                    {"len", "vec.len"},
+                                    {"capacity", "vec.buf.cap"},
+                                    {"is_empty", "vec.len == 0"}}));
+  rust_.emplace_back(InternalGlob("std::ffi::os_str::OsString"),
+                     std::make_unique<PrettyHeapString>(
+                         "inner.inner.buf.ptr.pointer.pointer as *u8", "inner.inner.len",
+                         GetterList{{"as_ptr", "inner.inner.buf.ptr.pointer.pointer as *u8"},
+                                    {"as_mut_ptr", "inner.inner.buf.ptr.pointer.pointer as *u8"},
+                                    {"len", "inner.inner.len"},
+                                    {"capacity", "inner.inner.buf.cap"},
+                                    {"is_empty", "inner.inner.len == 0"}}));
+  rust_.emplace_back(
+      InternalGlob("alloc::vec::Vec<*>"),
+      std::make_unique<PrettyArray>("buf.ptr.pointer.pointer", "len",
+                                    GetterList{{"as_ptr", "buf.ptr.pointer.pointer"},
+                                               {"as_mut_ptr", "buf.ptr.pointer.pointer"},
+                                               {"len", "len"},
+                                               {"capacity", "buf.cap"},
+                                               {"is_empty", "len == 0"}}));
 
   // A BinaryHeap is a wrapper around a "Vec" named "data".
   rust_.emplace_back(InternalGlob("alloc::collections::binary_heap::BinaryHeap<*>"),

src/developer/debug/zxdb/expr/pretty_type_manager_unittest.cc

diff --git a/src/developer/debug/zxdb/expr/pretty_type_manager_unittest.cc b/src/developer/debug/zxdb/expr/pretty_type_manager_unittest.cc
index 6d1425c..9185280 100644
--- a/src/developer/debug/zxdb/expr/pretty_type_manager_unittest.cc
+++ b/src/developer/debug/zxdb/expr/pretty_type_manager_unittest.cc
@@ -229,8 +229,12 @@
       DwarfTag::kStructureType, "Vec<*>",
       {{"buf", MakeCollectionType(
                    DwarfTag::kStructureType, "Buffer",
-                   {{"ptr", MakeCollectionType(DwarfTag::kStructureType, "Pointer",
-                                               {{"pointer", MakeRustCharPointerType()}})}})},
+                   {{"ptr", MakeCollectionType(
+                                DwarfTag::kStructureType, "Pointer",
+                                {{"pointer",
+                                  MakeCollectionType(
+                                      DwarfTag::kStructureType, "core::ptr::non_null::NonNull<u8>",
+                                      {{"pointer", MakeRustCharPointerType()}})}})}})},
        {"len", MakeUint64Type()},
        {"cap", MakeUint64Type()}});
   SymbolTestParentSetter vec_type_parent(vec_type, vec_namespace);