[lldb][NFCI] Remove use of Stream * from TypeSystem

[bulbazord]

Summary

We always assume these streams are valid, might as well take references
instead of raw pointers.

[fdeazeve]

LGTM!

lldb/include/lldb/Symbol/TypeSystem.h

 
 #ifndef NDEBUG
   /// Convenience LLVM-style dump method for use in the debugger only.
   LLVM_DUMP_METHOD virtual void
   dump(lldb::opaque_compiler_type_t type) const = 0;
 #endif
 
   virtual void DumpValue(lldb::opaque_compiler_type_t type,
-                         ExecutionContext *exe_ctx, Stream *s,
+                         ExecutionContext *exe_ctx, Stream &s,
                          lldb::Format format, const DataExtractor &data,
                          lldb::offset_t data_offset, size_t data_byte_size,
                          uint32_t bitfield_bit_size,
                          uint32_t bitfield_bit_offset, bool show_types,
                          bool show_summary, bool verbose, uint32_t depth) = 0;
 
-  virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
+  virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream &s,
                              lldb::Format format, const DataExtractor &data,
                              lldb::offset_t data_offset, size_t data_byte_size,
                              uint32_t bitfield_bit_size,
                              uint32_t bitfield_bit_offset,
                              ExecutionContextScope *exe_scope) = 0;
 
   /// Dump the type to stdout.
   virtual void DumpTypeDescription(
       lldb::opaque_compiler_type_t type,
       lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) = 0;
 
   /// Print a description of the type to a stream. The exact implementation
   /// varies, but the expectation is that eDescriptionLevelFull returns a
   /// source-like representation of the type, whereas eDescriptionLevelVerbose
   /// does a dump of the underlying AST if applicable.
   virtual void DumpTypeDescription(
-      lldb::opaque_compiler_type_t type, Stream *s,
+      lldb::opaque_compiler_type_t type, Stream &s,
       lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) = 0;
 
   /// Dump a textual representation of the internal TypeSystem state to the
   /// given stream.
   ///
   /// This should not modify the state of the TypeSystem if possible.
   virtual void Dump(llvm::raw_ostream &output) = 0;
 
   // TODO: These methods appear unused. Should they be removed?
 
   virtual bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) = 0;
 
   virtual void DumpSummary(lldb::opaque_compiler_type_t type,
-                           ExecutionContext *exe_ctx, Stream *s,
+                           ExecutionContext *exe_ctx, Stream &s,
                            const DataExtractor &data,
                            lldb::offset_t data_offset,
                            size_t data_byte_size) = 0;
 
   // TODO: Determine if these methods should move to TypeSystemClang.
 
   virtual bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type,
                                         CompilerType *pointee_type) = 0;

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

#endif
   ///
   /// \param[in] s
   ///       A stream to send the dumped AST node(s) to
   /// \param[in] symbol_name
   ///       The name of the symbol to dump, if it is empty dump all the symbols
   void DumpFromSymbolFile(Stream &s, llvm::StringRef symbol_name);
 
   void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
-                 Stream *s, lldb::Format format, const DataExtractor &data,
+                 Stream &s, lldb::Format format, const DataExtractor &data,
                  lldb::offset_t data_offset, size_t data_byte_size,
                  uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
                  bool show_types, bool show_summary, bool verbose,
                  uint32_t depth) override;
 
-  bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
+  bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream &s,
                      lldb::Format format, const DataExtractor &data,
                      lldb::offset_t data_offset, size_t data_byte_size,
                      uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
                      ExecutionContextScope *exe_scope) override;
 
   void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
-                   Stream *s, const DataExtractor &data,
+                   Stream &s, const DataExtractor &data,
                    lldb::offset_t data_offset, size_t data_byte_size) override;
 
   void DumpTypeDescription(
       lldb::opaque_compiler_type_t type,
       lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) override;
 
   void DumpTypeDescription(
-      lldb::opaque_compiler_type_t type, Stream *s,
+      lldb::opaque_compiler_type_t type, Stream &s,
       lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) override;
 
   static void DumpTypeName(const CompilerType &type);
 
   static clang::EnumDecl *GetAsEnumDecl(const CompilerType &type);
 
   static clang::RecordDecl *GetAsRecordDecl(const CompilerType &type);
 

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

case clang::Type::ObjCObject: {
           uint64_t bit_size = 0;
           if (objc_runtime->GetTypeBitSize(GetType(qual_type), bit_size))
             return bit_size;
         }
       } else {
         static bool g_printed = false;
         if (!g_printed) {
           StreamString s;
-          DumpTypeDescription(type, &s);
+          DumpTypeDescription(type, s);
 
           llvm::outs() << "warning: trying to determine the size of type ";
           llvm::outs() << s.GetString() << "\n";
           llvm::outs() << "without a valid ExecutionContext. this is not "
                           "reliable. please file a bug against LLDB.\n";
           llvm::outs() << "backtrace:\n";
           llvm::sys::PrintStackTrace(llvm::outs());
           llvm::outs() << "\n";
if (auto *objc_obj = llvm::dyn_cast<clang::ObjCObjectType>(
       }
     }
     GetCanonicalQualType(full_type.GetOpaqueQualType())
         .dump(s.AsRawOstream(), getASTContext());
   }
 }
 
 void TypeSystemClang::DumpValue(
-    lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
+    lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream &s,
     lldb::Format format, const lldb_private::DataExtractor &data,
     lldb::offset_t data_byte_offset, size_t data_byte_size,
     uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types,
     bool show_summary, bool verbose, uint32_t depth) {
   if (!type)
     return;
 
   clang::QualType qual_type(GetQualType(type));
if (GetCompleteType(type)) {
                 8;
           else
             field_bit_offset = record_layout.getBaseClassOffset(base_class_decl)
                                    .getQuantity() *
                                8;
           field_byte_offset = field_bit_offset / 8;
           assert(field_bit_offset % 8 == 0);
           if (child_idx == 0)
-            s->PutChar('{');
+            s.PutChar('{');
           else
-            s->PutChar(',');
+            s.PutChar(',');
 
           clang::QualType base_class_qual_type = base_class->getType();
           std::string base_class_type_name(base_class_qual_type.getAsString());
 
           // Indent and print the base class type name
-          s->Format("\n{0}{1}", llvm::fmt_repeat(" ", depth + DEPTH_INCREMENT),
+          s.Format("\n{0}{1}", llvm::fmt_repeat(" ", depth + DEPTH_INCREMENT),
                     base_class_type_name);
 
           clang::TypeInfo base_class_type_info =
               getASTContext().getTypeInfo(base_class_qual_type);
 
           // Dump the value of the member
           CompilerType base_clang_type = GetType(base_class_qual_type);
           base_clang_type.DumpValue(
               exe_ctx,
-              s, // Stream to dump to
+              &s, // Stream to dump to
               base_clang_type
                   .GetFormat(), // The format with which to display the member
               data, // Data buffer containing all bytes for this type
               data_byte_offset + field_byte_offset, // Offset into "data" where
                                                     // to grab value from
               base_class_type_info.Width / 8, // Size of this type in bytes
               0,                              // Bitfield bit size
               0,                              // Bitfield bit offset
if (GetCompleteType(type)) {
       uint32_t field_idx = 0;
       clang::RecordDecl::field_iterator field, field_end;
       for (field = record_decl->field_begin(),
           field_end = record_decl->field_end();
            field != field_end; ++field, ++field_idx, ++child_idx) {
         // Print the starting squiggly bracket (if this is the first member) or
         // comma (for member 2 and beyond) for the struct/union/class member.
         if (child_idx == 0)
-          s->PutChar('{');
+          s.PutChar('{');
         else
-          s->PutChar(',');
+          s.PutChar(',');
 
         // Indent
-        s->Printf("\n%*s", depth + DEPTH_INCREMENT, "");
+        s.Printf("\n%*s", depth + DEPTH_INCREMENT, "");
 
         clang::QualType field_type = field->getType();
         // Print the member type if requested
         // Figure out the type byte size (field_type_info.first) and alignment
         // (field_type_info.second) from the AST context.
         clang::TypeInfo field_type_info =
             getASTContext().getTypeInfo(field_type);
         assert(field_idx < record_layout.getFieldCount());
         // Figure out the field offset within the current struct/union/class
         // type
         field_bit_offset = record_layout.getFieldOffset(field_idx);
         field_byte_offset = field_bit_offset / 8;
         uint32_t field_bitfield_bit_size = 0;
         uint32_t field_bitfield_bit_offset = 0;
         if (FieldIsBitfield(*field, field_bitfield_bit_size))
           field_bitfield_bit_offset = field_bit_offset % 8;
 
         if (show_types) {
           std::string field_type_name(field_type.getAsString());
           if (field_bitfield_bit_size > 0)
-            s->Printf("(%s:%u) ", field_type_name.c_str(),
-                      field_bitfield_bit_size);
+            s.Printf("(%s:%u) ", field_type_name.c_str(),
           else
-            s->Printf("(%s) ", field_type_name.c_str());
+            s.Printf("(%s) ", field_type_name.c_str());
         }
         // Print the member name and equal sign
-        s->Printf("%s = ", field->getNameAsString().c_str());
+        s.Printf("%s = ", field->getNameAsString().c_str());
 
         // Dump the value of the member
         CompilerType field_clang_type = GetType(field_type);
         field_clang_type.DumpValue(
             exe_ctx,
-            s, // Stream to dump to
+            &s, // Stream to dump to
             field_clang_type
                 .GetFormat(), // The format with which to display the member
             data,             // Data buffer containing all bytes for this type
             data_byte_offset + field_byte_offset, // Offset into "data" where to
                                                   // grab value from
             field_type_info.Width / 8,            // Size of this type in bytes
             field_bitfield_bit_size,              // Bitfield bit size
             field_bitfield_bit_offset,            // Bitfield bit offset
             show_types,   // Boolean indicating if we should show the variable
                           // types
             show_summary, // Boolean indicating if we should show a summary for
                           // the current type
             verbose,      // Verbose output?
             depth + DEPTH_INCREMENT); // Scope depth for any types that have
                                       // children
       }
 
       // Indent the trailing squiggly bracket
       if (child_idx > 0)
-        s->Printf("\n%*s}", depth, "");
+        s.Printf("\n%*s}", depth, "");
     }
     return;
 
   case clang::Type::Enum:
     if (GetCompleteType(type)) {
       const clang::EnumType *enutype =
           llvm::cast<clang::EnumType>(qual_type.getTypePtr());
       const clang::EnumDecl *enum_decl = enutype->getDecl();
       assert(enum_decl);
       clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
       lldb::offset_t offset = data_byte_offset;
       const int64_t enum_value = data.GetMaxU64Bitfield(
           &offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset);
       for (enum_pos = enum_decl->enumerator_begin(),
           enum_end_pos = enum_decl->enumerator_end();
            enum_pos != enum_end_pos; ++enum_pos) {
         if (enum_pos->getInitVal() == enum_value) {
-          s->Printf("%s", enum_pos->getNameAsString().c_str());
+          s.Printf("%s", enum_pos->getNameAsString().c_str());
           return;
         }
       }
       // If we have gotten here we didn't get find the enumerator in the enum
       // decl, so just print the integer.
-      s->Printf("%" PRIi64, enum_value);
+      s.Printf("%" PRIi64, enum_value);
     }
     return;
 
   case clang::Type::ConstantArray: {
     const clang::ConstantArrayType *array =
         llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr());
     bool is_array_of_characters = false;
     clang::QualType element_qual_type = array->getElementType();
clang::TypeInfo field_type_info =
         getASTContext().getTypeInfo(element_qual_type);
 
     uint32_t element_idx = 0;
     uint32_t element_offset = 0;
     uint64_t element_byte_size = field_type_info.Width / 8;
     uint32_t element_stride = element_byte_size;
 
     if (is_array_of_characters) {
-      s->PutChar('"');
-      DumpDataExtractor(data, s, data_byte_offset, lldb::eFormatChar,
+      s.PutChar('"');
+      DumpDataExtractor(data, &s, data_byte_offset, lldb::eFormatChar,
                         element_byte_size, element_count, UINT32_MAX,
                         LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('"');
+      s.PutChar('"');
       return;
     } else {
       CompilerType element_clang_type = GetType(element_qual_type);
       lldb::Format element_format = element_clang_type.GetFormat();
 
       for (element_idx = 0; element_idx < element_count; ++element_idx) {
         // Print the starting squiggly bracket (if this is the first member) or
         // comman (for member 2 and beyong) for the struct/union/class member.
         if (element_idx == 0)
-          s->PutChar('{');
+          s.PutChar('{');
         else
-          s->PutChar(',');
+          s.PutChar(',');
 
         // Indent and print the index
-        s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx);
+        s.Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx);
 
         // Figure out the field offset within the current struct/union/class
         // type
         element_offset = element_idx * element_stride;
 
         // Dump the value of the member
         element_clang_type.DumpValue(
             exe_ctx,
-            s,              // Stream to dump to
+            &s,             // Stream to dump to
             element_format, // The format with which to display the element
             data,           // Data buffer containing all bytes for this type
             data_byte_offset +
                 element_offset, // Offset into "data" where to grab value from
             element_byte_size,  // Size of this type in bytes
             0,                  // Bitfield bit size
             0,                  // Bitfield bit offset
             show_types,   // Boolean indicating if we should show the variable
                           // types
             show_summary, // Boolean indicating if we should show a summary for
                           // the current type
             verbose,      // Verbose output?
             depth + DEPTH_INCREMENT); // Scope depth for any types that have
                                       // children
       }
 
       // Indent the trailing squiggly bracket
       if (element_idx > 0)
-        s->Printf("\n%*s}", depth, "");
+        s.Printf("\n%*s}", depth, "");
     }
   }
     return;
 
   case clang::Type::Typedef: {
     clang::QualType typedef_qual_type =
         llvm::cast<clang::TypedefType>(qual_type)
             ->getDecl()
             ->getUnderlyingType();
 
     CompilerType typedef_clang_type = GetType(typedef_qual_type);
     lldb::Format typedef_format = typedef_clang_type.GetFormat();
     clang::TypeInfo typedef_type_info =
         getASTContext().getTypeInfo(typedef_qual_type);
     uint64_t typedef_byte_size = typedef_type_info.Width / 8;
 
     return typedef_clang_type.DumpValue(
         exe_ctx,
-        s,                   // Stream to dump to
+        &s,                  // Stream to dump to
         typedef_format,      // The format with which to display the element
         data,                // Data buffer containing all bytes for this type
         data_byte_offset,    // Offset into "data" where to grab value from
         typedef_byte_size,   // Size of this type in bytes
         bitfield_bit_size,   // Bitfield bit size
         bitfield_bit_offset, // Bitfield bit offset
         show_types,   // Boolean indicating if we should show the variable types
         show_summary, // Boolean indicating if we should show a summary for the
                       // current type
         verbose,      // Verbose output?
         depth);       // Scope depth for any types that have children
   } break;
 
   case clang::Type::Auto: {
     clang::QualType elaborated_qual_type =
         llvm::cast<clang::AutoType>(qual_type)->getDeducedType();
     CompilerType elaborated_clang_type = GetType(elaborated_qual_type);
     lldb::Format elaborated_format = elaborated_clang_type.GetFormat();
     clang::TypeInfo elaborated_type_info =
         getASTContext().getTypeInfo(elaborated_qual_type);
     uint64_t elaborated_byte_size = elaborated_type_info.Width / 8;
 
     return elaborated_clang_type.DumpValue(
         exe_ctx,
-        s,                    // Stream to dump to
+        &s,                   // Stream to dump to
         elaborated_format,    // The format with which to display the element
         data,                 // Data buffer containing all bytes for this type
         data_byte_offset,     // Offset into "data" where to grab value from
         elaborated_byte_size, // Size of this type in bytes
         bitfield_bit_size,    // Bitfield bit size
         bitfield_bit_offset,  // Bitfield bit offset
         show_types,   // Boolean indicating if we should show the variable types
         show_summary, // Boolean indicating if we should show a summary for the
                       // current type
         verbose,      // Verbose output?
         depth);       // Scope depth for any types that have children
   } break;
 
   case clang::Type::Elaborated: {
     clang::QualType elaborated_qual_type =
         llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType();
     CompilerType elaborated_clang_type = GetType(elaborated_qual_type);
     lldb::Format elaborated_format = elaborated_clang_type.GetFormat();
     clang::TypeInfo elaborated_type_info =
         getASTContext().getTypeInfo(elaborated_qual_type);
     uint64_t elaborated_byte_size = elaborated_type_info.Width / 8;
 
     return elaborated_clang_type.DumpValue(
         exe_ctx,
-        s,                    // Stream to dump to
+        &s,                   // Stream to dump to
         elaborated_format,    // The format with which to display the element
         data,                 // Data buffer containing all bytes for this type
         data_byte_offset,     // Offset into "data" where to grab value from
         elaborated_byte_size, // Size of this type in bytes
         bitfield_bit_size,    // Bitfield bit size
         bitfield_bit_offset,  // Bitfield bit offset
         show_types,   // Boolean indicating if we should show the variable types
         show_summary, // Boolean indicating if we should show a summary for the
case clang::Type::Paren: {
 
     lldb::Format desugar_format = desugar_clang_type.GetFormat();
     clang::TypeInfo desugar_type_info =
         getASTContext().getTypeInfo(desugar_qual_type);
     uint64_t desugar_byte_size = desugar_type_info.Width / 8;
 
     return desugar_clang_type.DumpValue(
         exe_ctx,
-        s,                   // Stream to dump to
+        &s,                  // Stream to dump to
         desugar_format,      // The format with which to display the element
         data,                // Data buffer containing all bytes for this type
         data_byte_offset,    // Offset into "data" where to grab value from
         desugar_byte_size,   // Size of this type in bytes
         bitfield_bit_size,   // Bitfield bit size
         bitfield_bit_offset, // Bitfield bit offset
         show_types,   // Boolean indicating if we should show the variable types
         show_summary, // Boolean indicating if we should show a summary for the
                       // current type
         verbose,      // Verbose output?
         depth);       // Scope depth for any types that have children
   } break;
 
   default:
     // We are down to a scalar type that we just need to display.
-    DumpDataExtractor(data, s, data_byte_offset, format, data_byte_size, 1,
+    DumpDataExtractor(data, &s, data_byte_offset, format, data_byte_size, 1,
                       UINT32_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size,
                       bitfield_bit_offset);
 
     if (show_summary)
       DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
     break;
   }
 }
 
-static bool DumpEnumValue(const clang::QualType &qual_type, Stream *s,
+static bool DumpEnumValue(const clang::QualType &qual_type, Stream &s,
                           const DataExtractor &data, lldb::offset_t byte_offset,
                           size_t byte_size, uint32_t bitfield_bit_offset,
                           uint32_t bitfield_bit_size) {
   const clang::EnumType *enutype =
       llvm::cast<clang::EnumType>(qual_type.getTypePtr());
   const clang::EnumDecl *enum_decl = enutype->getDecl();
   assert(enum_decl);
   lldb::offset_t offset = byte_offset;
for (auto *enumerator : enum_decl->enumerators()) {
     uint64_t val = enumerator->getInitVal().getSExtValue();
     val = llvm::SignExtend64(val, 8*byte_size);
     if (llvm::popcount(val) != 1 && (val & ~covered_bits) != 0)
       can_be_bitfield = false;
     covered_bits |= val;
     ++num_enumerators;
     if (val == enum_svalue) {
       // Found an exact match, that's all we need to do.
-      s->PutCString(enumerator->getNameAsString());
+      s.PutCString(enumerator->getNameAsString());
       return true;
     }
   }
 
   // Unsigned values make more sense for flags.
   offset = byte_offset;
   const uint64_t enum_uvalue = data.GetMaxU64Bitfield(
       &offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
 
   // No exact match, but we don't think this is a bitfield. Print the value as
   // decimal.
   if (!can_be_bitfield) {
     if (qual_type->isSignedIntegerOrEnumerationType())
-      s->Printf("%" PRIi64, enum_svalue);
+      s.Printf("%" PRIi64, enum_svalue);
     else
-      s->Printf("%" PRIu64, enum_uvalue);
+      s.Printf("%" PRIu64, enum_uvalue);
     return true;
   }
 
   uint64_t remaining_value = enum_uvalue;
   std::vector<std::pair<uint64_t, llvm::StringRef>> values;
   values.reserve(num_enumerators);
   for (auto *enumerator : enum_decl->enumerators())
     if (auto val = enumerator->getInitVal().getZExtValue())
       values.emplace_back(val, enumerator->getName());
 
   // Sort in reverse order of the number of the population count,  so that in
   // `enum {A, B, ALL = A|B }` we visit ALL first. Use a stable sort so that
   // A | C where A is declared before C is displayed in this order.
   std::stable_sort(values.begin(), values.end(),
                    [](const auto &a, const auto &b) {
                      return llvm::popcount(a.first) > llvm::popcount(b.first);
                    });
 
   for (const auto &val : values) {
     if ((remaining_value & val.first) != val.first)
       continue;
     remaining_value &= ~val.first;
-    s->PutCString(val.second);
+    s.PutCString(val.second);
     if (remaining_value)
-      s->PutCString(" | ");
+      s.PutCString(" | ");
   }
 
   // If there is a remainder that is not covered by the value, print it as hex.
   if (remaining_value)
-    s->Printf("0x%" PRIx64, remaining_value);
+    s.Printf("0x%" PRIx64, remaining_value);
 
   return true;
 }
 
 bool TypeSystemClang::DumpTypeValue(
-    lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
+    lldb::opaque_compiler_type_t type, Stream &s, lldb::Format format,
     const lldb_private::DataExtractor &data, lldb::offset_t byte_offset,
     size_t byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
     ExecutionContextScope *exe_scope) {
   if (!type)
     return false;
   if (IsAggregateType(type)) {
     return false;
   } else {
case clang::Type::Typedef: {
       CompilerType typedef_clang_type = GetType(typedef_qual_type);
       if (format == eFormatDefault)
         format = typedef_clang_type.GetFormat();
       clang::TypeInfo typedef_type_info =
           getASTContext().getTypeInfo(typedef_qual_type);
       uint64_t typedef_byte_size = typedef_type_info.Width / 8;
 
       return typedef_clang_type.DumpTypeValue(
-          s,
+          &s,
           format,            // The format with which to display the element
           data,              // Data buffer containing all bytes for this type
           byte_offset,       // Offset into "data" where to grab value from
           typedef_byte_size, // Size of this type in bytes
           bitfield_bit_size, // Size in bits of a bitfield value, if zero don't
                              // treat as a bitfield
           bitfield_bit_offset, // Offset in bits of a bitfield value if
                                // bitfield_bit_size != 0
default:
           byte_size = 2;
           break;
 
         case eFormatUnicode32:
           item_count = byte_size / 4;
           byte_size = 4;
           break;
         }
-        return DumpDataExtractor(data, s, byte_offset, format, byte_size,
+        return DumpDataExtractor(data, &s, byte_offset, format, byte_size,
                                  item_count, UINT32_MAX, LLDB_INVALID_ADDRESS,
                                  bitfield_bit_size, bitfield_bit_offset,
                                  exe_scope);
       }
       break;
     }
   }
   return false;
 }
 
 void TypeSystemClang::DumpSummary(lldb::opaque_compiler_type_t type,
-                                  ExecutionContext *exe_ctx, Stream *s,
+                                  ExecutionContext *exe_ctx, Stream &s,
                                   const lldb_private::DataExtractor &data,
                                   lldb::offset_t data_byte_offset,
                                   size_t data_byte_size) {
   uint32_t length = 0;
   if (IsCStringType(type, length)) {
     if (exe_ctx) {
       Process *process = exe_ctx->GetProcessPtr();
       if (process) {
if (exe_ctx) {
         size_t total_cstr_len = 0;
         Status error;
         while ((bytes_read = process->ReadMemory(pointer_address, &buf.front(),
                                                  buf.size(), error)) > 0) {
           const size_t len = strlen((const char *)&buf.front());
           if (len == 0)
             break;
           if (total_cstr_len == 0)
-            s->PutCString(" \"");
-          DumpDataExtractor(cstr_data, s, 0, lldb::eFormatChar, 1, len,
+            s.PutCString(" \"");
+          DumpDataExtractor(cstr_data, &s, 0, lldb::eFormatChar, 1, len,
                             UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0);
           total_cstr_len += len;
           if (len < buf.size())
             break;
           pointer_address += total_cstr_len;
         }
         if (total_cstr_len > 0)
-          s->PutChar('"');
+          s.PutChar('"');
       }
     }
   }
 }
 
 void TypeSystemClang::DumpTypeDescription(lldb::opaque_compiler_type_t type,
                                           lldb::DescriptionLevel level) {
   StreamFile s(stdout, false);
-  DumpTypeDescription(type, &s, level);
+  DumpTypeDescription(type, s, level);
 
   CompilerType ct(weak_from_this(), type);
   const clang::Type *clang_type = ClangUtil::GetQualType(ct).getTypePtr();
   ClangASTMetadata *metadata = GetMetadata(clang_type);
   if (metadata) {
     metadata->Dump(&s);
   }
 }
 
 void TypeSystemClang::DumpTypeDescription(lldb::opaque_compiler_type_t type,
-                                          Stream *s,
+                                          Stream &s,
                                           lldb::DescriptionLevel level) {
   if (type) {
     clang::QualType qual_type =
         RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
 
     llvm::SmallVector<char, 1024> buf;
     llvm::raw_svector_ostream llvm_ostrm(buf);
 
case clang::Type::ObjCInterface: {
             objc_class_type->getInterface();
       if (!class_interface_decl)
         break;
       if (level == eDescriptionLevelVerbose)
         class_interface_decl->dump(llvm_ostrm);
       else
         class_interface_decl->print(llvm_ostrm,
                                     getASTContext().getPrintingPolicy(),
-                                    s->GetIndentLevel());
+                                    s.GetIndentLevel());
     } break;
 
     case clang::Type::Typedef: {
       auto *typedef_type = qual_type->getAs<clang::TypedefType>();
       if (!typedef_type)
         break;
       const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
       if (level == eDescriptionLevelVerbose)
         typedef_decl->dump(llvm_ostrm);
       else {
         std::string clang_typedef_name(GetTypeNameForDecl(typedef_decl));
         if (!clang_typedef_name.empty()) {
-          s->PutCString("typedef ");
-          s->PutCString(clang_typedef_name);
+          s.PutCString("typedef ");
+          s.PutCString(clang_typedef_name);
         }
       }
     } break;
 
     case clang::Type::Record: {
       GetCompleteType(type);
 
       auto *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
       const clang::RecordDecl *record_decl = record_type->getDecl();
       if (level == eDescriptionLevelVerbose)
         record_decl->dump(llvm_ostrm);
       else {
         record_decl->print(llvm_ostrm, getASTContext().getPrintingPolicy(),
-                           s->GetIndentLevel());
+                           s.GetIndentLevel());
       }
     } break;
 
     default: {
       if (auto *tag_type =
               llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr())) {
         if (clang::TagDecl *tag_decl = tag_type->getDecl()) {
           if (level == eDescriptionLevelVerbose)
             tag_decl->dump(llvm_ostrm);
           else
             tag_decl->print(llvm_ostrm, 0);
         }
       } else {
         if (level == eDescriptionLevelVerbose)
           qual_type->dump(llvm_ostrm, getASTContext());
         else {
           std::string clang_type_name(qual_type.getAsString());
           if (!clang_type_name.empty())
-            s->PutCString(clang_type_name);
+            s.PutCString(clang_type_name);
         }
       }
     }
     }
 
     if (buf.size() > 0) {
-      s->Write(buf.data(), buf.size());
+      s.Write(buf.data(), buf.size());
     }
 }
 }
 
 void TypeSystemClang::DumpTypeName(const CompilerType &type) {
   if (ClangUtil::IsClangType(type)) {
     clang::QualType qual_type(
         ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type)));

lldb/source/Symbol/CompilerType.cpp

 void CompilerType::DumpValue(ExecutionContext *exe_ctx, Stream *s,
                              lldb::Format format, const DataExtractor &data,
                              lldb::offset_t data_byte_offset,
                              size_t data_byte_size, uint32_t bitfield_bit_size,
                              uint32_t bitfield_bit_offset, bool show_types,
                              bool show_summary, bool verbose, uint32_t depth) {
   if (!IsValid())
     if (auto type_system_sp = GetTypeSystem())
-      type_system_sp->DumpValue(m_type, exe_ctx, s, format, data,
+      type_system_sp->DumpValue(m_type, exe_ctx, *s, format, data,
                                 data_byte_offset, data_byte_size,
                                 bitfield_bit_size, bitfield_bit_offset,
                                 show_types, show_summary, verbose, depth);
 }
 
 bool CompilerType::DumpTypeValue(Stream *s, lldb::Format format,
                                  const DataExtractor &data,
                                  lldb::offset_t byte_offset, size_t byte_size,
                                  uint32_t bitfield_bit_size,
                                  uint32_t bitfield_bit_offset,
                                  ExecutionContextScope *exe_scope) {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())
-      return type_system_sp->DumpTypeValue(m_type, s, format, data, byte_offset,
-                                           byte_size, bitfield_bit_size,
-                                           bitfield_bit_offset, exe_scope);
+      return type_system_sp->DumpTypeValue(
+          m_type, *s, format, data, byte_offset, byte_size, bitfield_bit_size,
   return false;
 }
 
 void CompilerType::DumpSummary(ExecutionContext *exe_ctx, Stream *s,
                                const DataExtractor &data,
                                lldb::offset_t data_byte_offset,
                                size_t data_byte_size) {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())
-      type_system_sp->DumpSummary(m_type, exe_ctx, s, data, data_byte_offset,
+      type_system_sp->DumpSummary(m_type, exe_ctx, *s, data, data_byte_offset,
                                   data_byte_size);
 }
 
 void CompilerType::DumpTypeDescription(lldb::DescriptionLevel level) const {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())
       type_system_sp->DumpTypeDescription(m_type, level);
 }
 
 void CompilerType::DumpTypeDescription(Stream *s,
                                        lldb::DescriptionLevel level) const {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())
-      type_system_sp->DumpTypeDescription(m_type, s, level);
+      type_system_sp->DumpTypeDescription(m_type, *s, level);
 }
 
 #ifndef NDEBUG
 LLVM_DUMP_METHOD void CompilerType::dump() const {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())
       return type_system_sp->dump(m_type);
   llvm::errs() << "<invalid>\n";