[Demangle] Rename OutputStream to OutputString

[ljmf00]

Summary

This patch is a refactor to implement prepend afterwards. Since this changes a lot of files and to conform with guidelines, I will separate this from the implementation of prepend. Related to the discussion in https://reviews.llvm.org/D111414 , so please read it for more context.

[Geod24]

llvm/include/llvm/Demangle/ItaniumDemangle.h

15

Why those changes ? IIUC the CI is failing on this file, too.

[dblaikie]

Sounds good - no doubt people could haggle over the name, but I think it'll do.

[ljmf00]

llvm/include/llvm/Demangle/ItaniumDemangle.h

15

This is because the script was verbatim copied. I think LLVM should address this in a more clean way, to be honest. These specific files are literally copied from one place to another and stuff like this can happen without being noticed. @dblaikie Currently, there is an effort to change this or any specific rationale to keep it this way?

[jhenderson]

llvm/include/llvm/Demangle/Utility.h

12–14

Another header guard that shouldn't be changed?

[ljmf00]

Include guards are now the same as before.

llvm/include/llvm/Demangle/Utility.h

12–14

Sorry, I missed that file too. Should be good now.

[dblaikie]

llvm/include/llvm/Demangle/ItaniumDemangle.h

15

Not quite following - but no, I don't think there's any effort at the moment to change this situation that these two files need to be kept in sync.

[ldionne]

libcxxabi/src/demangle/Utility.h

27

This was arguably written with the intent of being a stream -- that's why the class provides functions like operator<<. On the other hand, it also provides some functions like operator+=, which don't really belong in a stream, but do belong in a string.

I feel like this patch as-is kind of breaks what this class was supposed to be, since now we'll have a type that is neither a string nor a stream, but has both operator+= and operator<<. Do we use operator<< widely? If not, would it make sense to remove it altogether and make this closer to a real string? Otherwise, perhaps we could consider naming this something like OutputBuffer instead, which IMO makes it less vexing to have an operator<< defined on.

I don't want to stall this solely on picking a name, but I do feel like having a class called OutputString yet boasting operator<< is really un-idiomatic and I'd like to explore alternatives.

[dblaikie]

libcxxabi/src/demangle/Utility.h

27

OutputBuffer?

[ldionne]

libcxxabi/src/demangle/Utility.h

27

Yeah, that was my suggestion above. I'm still not a big fan of it but I find it a bit less weird than OutputString given the existence of operator<<.

[dblaikie]

libcxxabi/src/demangle/Utility.h

27

Ah, right, sorry, didn't see you'd already suggested that. @ljmf00 - could you make that change to OutputBuffer?

[ljmf00]

I amended the diff. I also renamed variable names to match the new type name, otherwise OS and S names would not make much sense. I renamed them to be OB.

[ljmf00]

llvm/include/llvm/Demangle/ItaniumDemangle.h

15

Those files need to be manually copied and manually changed to prevent the usage of the same include guard. This can be improved by e.g. generate a copy of this file with a generator script on the build system. I asked if there is any rationale to have it this way.

[dblaikie]

llvm/include/llvm/Demangle/ItaniumDemangle.h

15

Still not sure I'm following/understanding the question. If you mean: Is there any reason this is manual rather than automated? I doubt it, only that no one's managed to automate it yet, perhaps.

[ldionne]

LGTM but please wait for the CI to be finished (and green) before shipping.

[ljmf00]

In D111947#3079277, @ldionne wrote:

LGTM but please wait for the CI to be finished (and green) before shipping.

I can't land it, as I don't have permissions @dblaikie .

libcxxabi/src/demangle/ItaniumDemangle.h

public:
   template<typename Fn> void visit(Fn F) const;
 
   // The following function is provided by all derived classes:
   //
   // Call F with arguments that, when passed to the constructor of this node,
   // would construct an equivalent node.
   //template<typename Fn> void match(Fn F) const;
 
-  bool hasRHSComponent(OutputStream &S) const {
+  bool hasRHSComponent(OutputString &S) const {
     if (RHSComponentCache != Cache::Unknown)
       return RHSComponentCache == Cache::Yes;
     return hasRHSComponentSlow(S);
   }
 
-  bool hasArray(OutputStream &S) const {
+  bool hasArray(OutputString &S) const {
     if (ArrayCache != Cache::Unknown)
       return ArrayCache == Cache::Yes;
     return hasArraySlow(S);
   }
 
-  bool hasFunction(OutputStream &S) const {
+  bool hasFunction(OutputString &S) const {
     if (FunctionCache != Cache::Unknown)
       return FunctionCache == Cache::Yes;
     return hasFunctionSlow(S);
   }
 
   Kind getKind() const { return K; }
 
-  virtual bool hasRHSComponentSlow(OutputStream &) const { return false; }
-  virtual bool hasArraySlow(OutputStream &) const { return false; }
-  virtual bool hasFunctionSlow(OutputStream &) const { return false; }
+  virtual bool hasRHSComponentSlow(OutputString &) const { return false; }
+  virtual bool hasArraySlow(OutputString &) const { return false; }
+  virtual bool hasFunctionSlow(OutputString &) const { return false; }
 
   // Dig through "glue" nodes like ParameterPack and ForwardTemplateReference to
   // get at a node that actually represents some concrete syntax.
-  virtual const Node *getSyntaxNode(OutputStream &) const {
+  virtual const Node *getSyntaxNode(OutputString &) const {
     return this;
   }
 
-  void print(OutputStream &S) const {
+  void print(OutputString &S) const {
     printLeft(S);
     if (RHSComponentCache != Cache::No)
       printRight(S);
   }
 
-  // Print the "left" side of this Node into OutputStream.
-  virtual void printLeft(OutputStream &) const = 0;
+  // Print the "left" side of this Node into OutputString.
+  virtual void printLeft(OutputString &) const = 0;
 
   // Print the "right". This distinction is necessary to represent C++ types
   // that appear on the RHS of their subtype, such as arrays or functions.
   // Since most types don't have such a component, provide a default
   // implementation.
-  virtual void printRight(OutputStream &) const {}
+  virtual void printRight(OutputString &) const {}
 
   virtual StringView getBaseName() const { return StringView(); }
 
   // Silence compiler warnings, this dtor will never be called.
   virtual ~Node() = default;
 
 #ifndef NDEBUG
   DEMANGLE_DUMP_METHOD void dump() const;
public:
   bool empty() const { return NumElements == 0; }
   size_t size() const { return NumElements; }
 
   Node **begin() const { return Elements; }
   Node **end() const { return Elements + NumElements; }
 
   Node *operator[](size_t Idx) const { return Elements[Idx]; }
 
-  void printWithComma(OutputStream &S) const {
+  void printWithComma(OutputString &S) const {
     bool FirstElement = true;
     for (size_t Idx = 0; Idx != NumElements; ++Idx) {
       size_t BeforeComma = S.getCurrentPosition();
       if (!FirstElement)
         S += ", ";
       size_t AfterComma = S.getCurrentPosition();
       Elements[Idx]->print(S);
 

 };
 
 struct NodeArrayNode : Node {
   NodeArray Array;
   NodeArrayNode(NodeArray Array_) : Node(KNodeArrayNode), Array(Array_) {}
 
   template<typename Fn> void match(Fn F) const { F(Array); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Array.printWithComma(S);
   }
 };
 
 class DotSuffix final : public Node {
   const Node *Prefix;
   const StringView Suffix;
 
 public:
   DotSuffix(const Node *Prefix_, StringView Suffix_)
       : Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
 
   template<typename Fn> void match(Fn F) const { F(Prefix, Suffix); }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     Prefix->print(s);
     s += " (";
     s += Suffix;
     s += ")";
   }
 };
 
 class VendorExtQualType final : public Node {
   const Node *Ty;
   StringView Ext;
   const Node *TA;
 
 public:
   VendorExtQualType(const Node *Ty_, StringView Ext_, const Node *TA_)
       : Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {}
 
   template <typename Fn> void match(Fn F) const { F(Ty, Ext, TA); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Ty->print(S);
     S += " ";
     S += Ext;
     if (TA != nullptr)
       TA->print(S);
   }
 };
 
inline Qualifiers operator|=(Qualifiers &Q1, Qualifiers Q2) {
   return Q1 = static_cast<Qualifiers>(Q1 | Q2);
 }
 
 class QualType final : public Node {
 protected:
   const Qualifiers Quals;
   const Node *Child;
 
-  void printQuals(OutputStream &S) const {
+  void printQuals(OutputString &S) const {
     if (Quals & QualConst)
       S += " const";
     if (Quals & QualVolatile)
       S += " volatile";
     if (Quals & QualRestrict)
       S += " restrict";
   }
 
 public:
   QualType(const Node *Child_, Qualifiers Quals_)
       : Node(KQualType, Child_->RHSComponentCache,
              Child_->ArrayCache, Child_->FunctionCache),
         Quals(Quals_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child, Quals); }
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     return Child->hasRHSComponent(S);
   }
-  bool hasArraySlow(OutputStream &S) const override {
+  bool hasArraySlow(OutputString &S) const override {
     return Child->hasArray(S);
   }
-  bool hasFunctionSlow(OutputStream &S) const override {
+  bool hasFunctionSlow(OutputString &S) const override {
     return Child->hasFunction(S);
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Child->printLeft(S);
     printQuals(S);
   }
 
-  void printRight(OutputStream &S) const override { Child->printRight(S); }
+  void printRight(OutputString &S) const override { Child->printRight(S); }
 };
 
 class ConversionOperatorType final : public Node {
   const Node *Ty;
 
 public:
   ConversionOperatorType(const Node *Ty_)
       : Node(KConversionOperatorType), Ty(Ty_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "operator ";
     Ty->print(S);
   }
 };
 
 class PostfixQualifiedType final : public Node {
   const Node *Ty;
   const StringView Postfix;
 
 public:
   PostfixQualifiedType(Node *Ty_, StringView Postfix_)
       : Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Postfix); }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     Ty->printLeft(s);
     s += Postfix;
   }
 };
 
 class NameType final : public Node {
   const StringView Name;
 
 public:
   NameType(StringView Name_) : Node(KNameType), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name); }
 
   StringView getName() const { return Name; }
   StringView getBaseName() const override { return Name; }
 
-  void printLeft(OutputStream &s) const override { s += Name; }
+  void printLeft(OutputString &s) const override { s += Name; }
 };
 
 class ElaboratedTypeSpefType : public Node {
   StringView Kind;
   Node *Child;
 public:
   ElaboratedTypeSpefType(StringView Kind_, Node *Child_)
       : Node(KElaboratedTypeSpefType), Kind(Kind_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Kind, Child); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += Kind;
     S += ' ';
     Child->print(S);
   }
 };
 
 struct AbiTagAttr : Node {
   Node *Base;
   StringView Tag;
 
   AbiTagAttr(Node* Base_, StringView Tag_)
       : Node(KAbiTagAttr, Base_->RHSComponentCache,
              Base_->ArrayCache, Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
 
   template<typename Fn> void match(Fn F) const { F(Base, Tag); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Base->printLeft(S);
     S += "[abi:";
     S += Tag;
     S += "]";
   }
 };
 
 class EnableIfAttr : public Node {
   NodeArray Conditions;
 public:
   EnableIfAttr(NodeArray Conditions_)
       : Node(KEnableIfAttr), Conditions(Conditions_) {}
 
   template<typename Fn> void match(Fn F) const { F(Conditions); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += " [enable_if:";
     Conditions.printWithComma(S);
     S += ']';
   }
 };
 
 class ObjCProtoName : public Node {
   const Node *Ty;
   StringView Protocol;
 
   friend class PointerType;
 
 public:
   ObjCProtoName(const Node *Ty_, StringView Protocol_)
       : Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Protocol); }
 
   bool isObjCObject() const {
     return Ty->getKind() == KNameType &&
            static_cast<const NameType *>(Ty)->getName() == "objc_object";
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Ty->print(S);
     S += "<";
     S += Protocol;
     S += ">";
   }
 };
 
 class PointerType final : public Node {
   const Node *Pointee;
 
 public:
   PointerType(const Node *Pointee_)
       : Node(KPointerType, Pointee_->RHSComponentCache),
         Pointee(Pointee_) {}
 
   template<typename Fn> void match(Fn F) const { F(Pointee); }
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     return Pointee->hasRHSComponent(S);
   }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     // We rewrite objc_object<SomeProtocol>* into id<SomeProtocol>.
     if (Pointee->getKind() != KObjCProtoName ||
         !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
       Pointee->printLeft(s);
       if (Pointee->hasArray(s))
         s += " ";
       if (Pointee->hasArray(s) || Pointee->hasFunction(s))
         s += "(";
       s += "*";
     } else {
       const auto *objcProto = static_cast<const ObjCProtoName *>(Pointee);
       s += "id<";
       s += objcProto->Protocol;
       s += ">";
     }
   }
 
-  void printRight(OutputStream &s) const override {
+  void printRight(OutputString &s) const override {
     if (Pointee->getKind() != KObjCProtoName ||
         !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
       if (Pointee->hasArray(s) || Pointee->hasFunction(s))
         s += ")";
       Pointee->printRight(s);
     }
   }
 };
class ReferenceType : public Node {
 
   // Dig through any refs to refs, collapsing the ReferenceTypes as we go. The
   // rule here is rvalue ref to rvalue ref collapses to a rvalue ref, and any
   // other combination collapses to a lvalue ref.
   //
   // A combination of a TemplateForwardReference and a back-ref Substitution
   // from an ill-formed string may have created a cycle; use cycle detection to
   // avoid looping forever.
-  std::pair<ReferenceKind, const Node *> collapse(OutputStream &S) const {
+  std::pair<ReferenceKind, const Node *> collapse(OutputString &S) const {
     auto SoFar = std::make_pair(RK, Pointee);
     // Track the chain of nodes for the Floyd's 'tortoise and hare'
     // cycle-detection algorithm, since getSyntaxNode(S) is impure
     PODSmallVector<const Node *, 8> Prev;
     for (;;) {
       const Node *SN = SoFar.second->getSyntaxNode(S);
       if (SN->getKind() != KReferenceType)
         break;

 
 public:
   ReferenceType(const Node *Pointee_, ReferenceKind RK_)
       : Node(KReferenceType, Pointee_->RHSComponentCache),
         Pointee(Pointee_), RK(RK_) {}
 
   template<typename Fn> void match(Fn F) const { F(Pointee, RK); }
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     return Pointee->hasRHSComponent(S);
   }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     if (Printing)
       return;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     std::pair<ReferenceKind, const Node *> Collapsed = collapse(s);
     if (!Collapsed.second)
       return;
     Collapsed.second->printLeft(s);
     if (Collapsed.second->hasArray(s))
       s += " ";
     if (Collapsed.second->hasArray(s) || Collapsed.second->hasFunction(s))
       s += "(";
 
     s += (Collapsed.first == ReferenceKind::LValue ? "&" : "&&");
   }
-  void printRight(OutputStream &s) const override {
+  void printRight(OutputString &s) const override {
     if (Printing)
       return;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     std::pair<ReferenceKind, const Node *> Collapsed = collapse(s);
     if (!Collapsed.second)
       return;
     if (Collapsed.second->hasArray(s) || Collapsed.second->hasFunction(s))
       s += ")";
     Collapsed.second->printRight(s);
   }
 };
 
 class PointerToMemberType final : public Node {
   const Node *ClassType;
   const Node *MemberType;
 
 public:
   PointerToMemberType(const Node *ClassType_, const Node *MemberType_)
       : Node(KPointerToMemberType, MemberType_->RHSComponentCache),
         ClassType(ClassType_), MemberType(MemberType_) {}
 
   template<typename Fn> void match(Fn F) const { F(ClassType, MemberType); }
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     return MemberType->hasRHSComponent(S);
   }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     MemberType->printLeft(s);
     if (MemberType->hasArray(s) || MemberType->hasFunction(s))
       s += "(";
     else
       s += " ";
     ClassType->print(s);
     s += "::*";
   }
 
-  void printRight(OutputStream &s) const override {
+  void printRight(OutputString &s) const override {
     if (MemberType->hasArray(s) || MemberType->hasFunction(s))
       s += ")";
     MemberType->printRight(s);
   }
 };
 
 class ArrayType final : public Node {
   const Node *Base;
   Node *Dimension;
 
 public:
   ArrayType(const Node *Base_, Node *Dimension_)
       : Node(KArrayType,
              /*RHSComponentCache=*/Cache::Yes,
              /*ArrayCache=*/Cache::Yes),
         Base(Base_), Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(Base, Dimension); }
 
-  bool hasRHSComponentSlow(OutputStream &) const override { return true; }
-  bool hasArraySlow(OutputStream &) const override { return true; }
+  bool hasRHSComponentSlow(OutputString &) const override { return true; }
+  bool hasArraySlow(OutputString &) const override { return true; }
 
-  void printLeft(OutputStream &S) const override { Base->printLeft(S); }
+  void printLeft(OutputString &S) const override { Base->printLeft(S); }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     if (S.back() != ']')
       S += " ";
     S += "[";
     if (Dimension)
       Dimension->print(S);
     S += "]";
     Base->printRight(S);
   }
FunctionType(const Node *Ret_, NodeArray Params_, Qualifiers CVQuals_,
              /*FunctionCache=*/Cache::Yes),
         Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_),
         ExceptionSpec(ExceptionSpec_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(Ret, Params, CVQuals, RefQual, ExceptionSpec);
   }
 
-  bool hasRHSComponentSlow(OutputStream &) const override { return true; }
-  bool hasFunctionSlow(OutputStream &) const override { return true; }
+  bool hasRHSComponentSlow(OutputString &) const override { return true; }
+  bool hasFunctionSlow(OutputString &) const override { return true; }
 
   // Handle C++'s ... quirky decl grammar by using the left & right
   // distinction. Consider:
   //   int (*f(float))(char) {}
   // f is a function that takes a float and returns a pointer to a function
   // that takes a char and returns an int. If we're trying to print f, start
   // by printing out the return types's left, then print our parameters, then
   // finally print right of the return type.
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Ret->printLeft(S);
     S += " ";
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     S += "(";
     Params.printWithComma(S);
     S += ")";
     Ret->printRight(S);
 
     if (CVQuals & QualConst)
       S += " const";
     if (CVQuals & QualVolatile)

 
 class NoexceptSpec : public Node {
   const Node *E;
 public:
   NoexceptSpec(const Node *E_) : Node(KNoexceptSpec), E(E_) {}
 
   template<typename Fn> void match(Fn F) const { F(E); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "noexcept(";
     E->print(S);
     S += ")";
   }
 };
 
 class DynamicExceptionSpec : public Node {
   NodeArray Types;
 public:
   DynamicExceptionSpec(NodeArray Types_)
       : Node(KDynamicExceptionSpec), Types(Types_) {}
 
   template<typename Fn> void match(Fn F) const { F(Types); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "throw(";
     Types.printWithComma(S);
     S += ')';
   }
 };
 
 class FunctionEncoding final : public Node {
   const Node *Ret;
template<typename Fn> void match(Fn F) const {
     F(Ret, Name, Params, Attrs, CVQuals, RefQual);
   }
 
   Qualifiers getCVQuals() const { return CVQuals; }
   FunctionRefQual getRefQual() const { return RefQual; }
   NodeArray getParams() const { return Params; }
   const Node *getReturnType() const { return Ret; }
 
-  bool hasRHSComponentSlow(OutputStream &) const override { return true; }
-  bool hasFunctionSlow(OutputStream &) const override { return true; }
+  bool hasRHSComponentSlow(OutputString &) const override { return true; }
+  bool hasFunctionSlow(OutputString &) const override { return true; }
 
   const Node *getName() const { return Name; }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (Ret) {
       Ret->printLeft(S);
       if (!Ret->hasRHSComponent(S))
         S += " ";
     }
     Name->print(S);
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     S += "(";
     Params.printWithComma(S);
     S += ")";
     if (Ret)
       Ret->printRight(S);
 
     if (CVQuals & QualConst)
       S += " const";
class LiteralOperator : public Node {
   const Node *OpName;
 
 public:
   LiteralOperator(const Node *OpName_)
       : Node(KLiteralOperator), OpName(OpName_) {}
 
   template<typename Fn> void match(Fn F) const { F(OpName); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "operator\"\" ";
     OpName->print(S);
   }
 };
 
 class SpecialName final : public Node {
   const StringView Special;
   const Node *Child;
 
 public:
   SpecialName(StringView Special_, const Node *Child_)
       : Node(KSpecialName), Special(Special_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Special, Child); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += Special;
     Child->print(S);
   }
 };
 
 class CtorVtableSpecialName final : public Node {
   const Node *FirstType;
   const Node *SecondType;
 
 public:
   CtorVtableSpecialName(const Node *FirstType_, const Node *SecondType_)
       : Node(KCtorVtableSpecialName),
         FirstType(FirstType_), SecondType(SecondType_) {}
 
   template<typename Fn> void match(Fn F) const { F(FirstType, SecondType); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "construction vtable for ";
     FirstType->print(S);
     S += "-in-";
     SecondType->print(S);
   }
 };
 
 struct NestedName : Node {
   Node *Qual;
   Node *Name;
 
   NestedName(Node *Qual_, Node *Name_)
       : Node(KNestedName), Qual(Qual_), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Qual, Name); }
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Qual->print(S);
     S += "::";
     Name->print(S);
   }
 };
 
 struct LocalName : Node {
   Node *Encoding;
   Node *Entity;
 
   LocalName(Node *Encoding_, Node *Entity_)
       : Node(KLocalName), Encoding(Encoding_), Entity(Entity_) {}
 
   template<typename Fn> void match(Fn F) const { F(Encoding, Entity); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Encoding->print(S);
     S += "::";
     Entity->print(S);
   }
 };
 
 class QualifiedName final : public Node {
   // qualifier::name
   const Node *Qualifier;
   const Node *Name;
 
 public:
   QualifiedName(const Node *Qualifier_, const Node *Name_)
       : Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Qualifier, Name); }
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Qualifier->print(S);
     S += "::";
     Name->print(S);
   }
 };
 
 class VectorType final : public Node {
   const Node *BaseType;
   const Node *Dimension;
 
 public:
   VectorType(const Node *BaseType_, Node *Dimension_)
       : Node(KVectorType), BaseType(BaseType_),
         Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(BaseType, Dimension); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     BaseType->print(S);
     S += " vector[";
     if (Dimension)
       Dimension->print(S);
     S += "]";
   }
 };
 
 class PixelVectorType final : public Node {
   const Node *Dimension;
 
 public:
   PixelVectorType(const Node *Dimension_)
       : Node(KPixelVectorType), Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(Dimension); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     // FIXME: This should demangle as "vector pixel".
     S += "pixel vector[";
     Dimension->print(S);
     S += "]";
   }
 };
 
 class BinaryFPType final : public Node {
   const Node *Dimension;
 
 public:
   BinaryFPType(const Node *Dimension_)
       : Node(KBinaryFPType), Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(Dimension); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "_Float";
     Dimension->print(S);
   }
 };
 
 enum class TemplateParamKind { Type, NonType, Template };
 
 /// An invented name for a template parameter for which we don't have a
 /// corresponding template argument.
 ///
 /// This node is created when parsing the <lambda-sig> for a lambda with
 /// explicit template arguments, which might be referenced in the parameter
 /// types appearing later in the <lambda-sig>.
 class SyntheticTemplateParamName final : public Node {
   TemplateParamKind Kind;
   unsigned Index;
 
 public:
   SyntheticTemplateParamName(TemplateParamKind Kind_, unsigned Index_)
       : Node(KSyntheticTemplateParamName), Kind(Kind_), Index(Index_) {}
 
   template<typename Fn> void match(Fn F) const { F(Kind, Index); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     switch (Kind) {
     case TemplateParamKind::Type:
       S += "$T";
       break;
     case TemplateParamKind::NonType:
       S += "$N";
       break;
     case TemplateParamKind::Template:
class TypeTemplateParamDecl final : public Node {
   Node *Name;
 
 public:
   TypeTemplateParamDecl(Node *Name_)
       : Node(KTypeTemplateParamDecl, Cache::Yes), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "typename ";
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     Name->print(S);
   }
 };
 
 /// A non-type template parameter declaration, 'int N'.
 class NonTypeTemplateParamDecl final : public Node {
   Node *Name;
   Node *Type;
 
 public:
   NonTypeTemplateParamDecl(Node *Name_, Node *Type_)
       : Node(KNonTypeTemplateParamDecl, Cache::Yes), Name(Name_), Type(Type_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, Type); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Type->printLeft(S);
     if (!Type->hasRHSComponent(S))
       S += " ";
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     Name->print(S);
     Type->printRight(S);
   }
 };
 
 /// A template template parameter declaration,
 /// 'template<typename T> typename N'.
 class TemplateTemplateParamDecl final : public Node {
   Node *Name;
   NodeArray Params;
 
 public:
   TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
       : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
         Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, Params); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "template<";
     Params.printWithComma(S);
     S += "> typename ";
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     Name->print(S);
   }
 };
 
 /// A template parameter pack declaration, 'typename ...T'.
 class TemplateParamPackDecl final : public Node {
   Node *Param;
 
 public:
   TemplateParamPackDecl(Node *Param_)
       : Node(KTemplateParamPackDecl, Cache::Yes), Param(Param_) {}
 
   template<typename Fn> void match(Fn F) const { F(Param); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Param->printLeft(S);
     S += "...";
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     Param->printRight(S);
   }
 };
 
 /// An unexpanded parameter pack (either in the expression or type context). If
 /// this AST is correct, this node will have a ParameterPackExpansion node above
 /// it.
 ///
 /// This node is created when some <template-args> are found that apply to an
 /// <encoding>, and is stored in the TemplateParams table. In order for this to
 /// appear in the final AST, it has to referenced via a <template-param> (ie,
 /// T_).
 class ParameterPack final : public Node {
   NodeArray Data;
 
-  // Setup OutputStream for a pack expansion unless we're already expanding one.
-  void initializePackExpansion(OutputStream &S) const {
+  // Setup OutputString for a pack expansion unless we're already expanding one.
+  void initializePackExpansion(OutputString &S) const {
     if (S.CurrentPackMax == std::numeric_limits<unsigned>::max()) {
       S.CurrentPackMax = static_cast<unsigned>(Data.size());
       S.CurrentPackIndex = 0;
     }
   }
 
 public:
   ParameterPack(NodeArray Data_) : Node(KParameterPack), Data(Data_) {
ParameterPack(NodeArray Data_) : Node(KParameterPack), Data(Data_) {
     if (std::all_of(Data.begin(), Data.end(), [](Node* P) {
           return P->RHSComponentCache == Cache::No;
         }))
       RHSComponentCache = Cache::No;
   }
 
   template<typename Fn> void match(Fn F) const { F(Data); }
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     return Idx < Data.size() && Data[Idx]->hasRHSComponent(S);
   }
-  bool hasArraySlow(OutputStream &S) const override {
+  bool hasArraySlow(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     return Idx < Data.size() && Data[Idx]->hasArray(S);
   }
-  bool hasFunctionSlow(OutputStream &S) const override {
+  bool hasFunctionSlow(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     return Idx < Data.size() && Data[Idx]->hasFunction(S);
   }
-  const Node *getSyntaxNode(OutputStream &S) const override {
+  const Node *getSyntaxNode(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     return Idx < Data.size() ? Data[Idx]->getSyntaxNode(S) : this;
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     if (Idx < Data.size())
       Data[Idx]->printLeft(S);
   }
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     if (Idx < Data.size())
       Data[Idx]->printRight(S);
   }
 };
 
 /// A variadic template argument. This node represents an occurrence of
 /// J<something>E in some <template-args>. It isn't itself unexpanded, unless
 /// one of it's Elements is. The parser inserts a ParameterPack into the
 /// TemplateParams table if the <template-args> this pack belongs to apply to an
 /// <encoding>.
 class TemplateArgumentPack final : public Node {
   NodeArray Elements;
 public:
   TemplateArgumentPack(NodeArray Elements_)
       : Node(KTemplateArgumentPack), Elements(Elements_) {}
 
   template<typename Fn> void match(Fn F) const { F(Elements); }
 
   NodeArray getElements() const { return Elements; }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Elements.printWithComma(S);
   }
 };
 
 /// A pack expansion. Below this node, there are some unexpanded ParameterPacks
 /// which each have Child->ParameterPackSize elements.
 class ParameterPackExpansion final : public Node {
   const Node *Child;
 
 public:
   ParameterPackExpansion(const Node *Child_)
       : Node(KParameterPackExpansion), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child); }
 
   const Node *getChild() const { return Child; }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     constexpr unsigned Max = std::numeric_limits<unsigned>::max();
     SwapAndRestore<unsigned> SavePackIdx(S.CurrentPackIndex, Max);
     SwapAndRestore<unsigned> SavePackMax(S.CurrentPackMax, Max);
     size_t StreamPos = S.getCurrentPosition();
 
     // Print the first element in the pack. If Child contains a ParameterPack,
     // it will set up S.CurrentPackMax and print the first element.
     Child->print(S);

 
 public:
   TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Params); }
 
   NodeArray getParams() { return Params; }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "<";
     Params.printWithComma(S);
     if (S.back() == '>')
       S += " ";
     S += ">";
   }
 };
 
ForwardTemplateReference(size_t Index_)
              Cache::Unknown),
         Index(Index_) {}
 
   // We don't provide a matcher for these, because the value of the node is
   // not determined by its construction parameters, and it generally needs
   // special handling.
   template<typename Fn> void match(Fn F) const = delete;
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     if (Printing)
       return false;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     return Ref->hasRHSComponent(S);
   }
-  bool hasArraySlow(OutputStream &S) const override {
+  bool hasArraySlow(OutputString &S) const override {
     if (Printing)
       return false;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     return Ref->hasArray(S);
   }
-  bool hasFunctionSlow(OutputStream &S) const override {
+  bool hasFunctionSlow(OutputString &S) const override {
     if (Printing)
       return false;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     return Ref->hasFunction(S);
   }
-  const Node *getSyntaxNode(OutputStream &S) const override {
+  const Node *getSyntaxNode(OutputString &S) const override {
     if (Printing)
       return this;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     return Ref->getSyntaxNode(S);
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (Printing)
       return;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     Ref->printLeft(S);
   }
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     if (Printing)
       return;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     Ref->printRight(S);
   }
 };
 
 struct NameWithTemplateArgs : Node {
   // name<template_args>
   Node *Name;
   Node *TemplateArgs;
 
   NameWithTemplateArgs(Node *Name_, Node *TemplateArgs_)
       : Node(KNameWithTemplateArgs), Name(Name_), TemplateArgs(TemplateArgs_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, TemplateArgs); }
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Name->print(S);
     TemplateArgs->print(S);
   }
 };
 
 class GlobalQualifiedName final : public Node {
   Node *Child;
 
 public:
   GlobalQualifiedName(Node* Child_)
       : Node(KGlobalQualifiedName), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child); }
 
   StringView getBaseName() const override { return Child->getBaseName(); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "::";
     Child->print(S);
   }
 };
 
 struct StdQualifiedName : Node {
   Node *Child;
 
   StdQualifiedName(Node *Child_) : Node(KStdQualifiedName), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child); }
 
   StringView getBaseName() const override { return Child->getBaseName(); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "std::";
     Child->print(S);
   }
 };
 
 enum class SpecialSubKind {
   allocator,
   basic_string,
StringView getBaseName() const override {
     case SpecialSubKind::ostream:
       return StringView("basic_ostream");
     case SpecialSubKind::iostream:
       return StringView("basic_iostream");
     }
     DEMANGLE_UNREACHABLE;
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     switch (SSK) {
     case SpecialSubKind::allocator:
       S += "std::allocator";
       break;
     case SpecialSubKind::basic_string:
       S += "std::basic_string";
       break;
     case SpecialSubKind::string:
StringView getBaseName() const override {
     case SpecialSubKind::ostream:
       return StringView("ostream");
     case SpecialSubKind::iostream:
       return StringView("iostream");
     }
     DEMANGLE_UNREACHABLE;
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     switch (SSK) {
     case SpecialSubKind::allocator:
       S += "std::allocator";
       break;
     case SpecialSubKind::basic_string:
       S += "std::basic_string";
       break;
     case SpecialSubKind::string:

 
 public:
   CtorDtorName(const Node *Basename_, bool IsDtor_, int Variant_)
       : Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_),
         Variant(Variant_) {}
 
   template<typename Fn> void match(Fn F) const { F(Basename, IsDtor, Variant); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (IsDtor)
       S += "~";
     S += Basename->getBaseName();
   }
 };
 
 class DtorName : public Node {
   const Node *Base;
 
 public:
   DtorName(const Node *Base_) : Node(KDtorName), Base(Base_) {}
 
   template<typename Fn> void match(Fn F) const { F(Base); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "~";
     Base->printLeft(S);
   }
 };
 
 class UnnamedTypeName : public Node {
   const StringView Count;
 
 public:
   UnnamedTypeName(StringView Count_) : Node(KUnnamedTypeName), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const { F(Count); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "'unnamed";
     S += Count;
     S += "\'";
   }
 };
 
 class ClosureTypeName : public Node {
   NodeArray TemplateParams;
   NodeArray Params;
   StringView Count;
 
 public:
   ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
                   StringView Count_)
       : Node(KClosureTypeName), TemplateParams(TemplateParams_),
         Params(Params_), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(TemplateParams, Params, Count);
   }
 
-  void printDeclarator(OutputStream &S) const {
+  void printDeclarator(OutputString &S) const {
     if (!TemplateParams.empty()) {
       S += "<";
       TemplateParams.printWithComma(S);
       S += ">";
     }
     S += "(";
     Params.printWithComma(S);
     S += ")";
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "\'lambda";
     S += Count;
     S += "\'";
     printDeclarator(S);
   }
 };
 
 class StructuredBindingName : public Node {
   NodeArray Bindings;
 public:
   StructuredBindingName(NodeArray Bindings_)
       : Node(KStructuredBindingName), Bindings(Bindings_) {}
 
   template<typename Fn> void match(Fn F) const { F(Bindings); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += '[';
     Bindings.printWithComma(S);
     S += ']';
   }
 };
 
 // -- Expression Nodes --
 
 class BinaryExpr : public Node {
   const Node *LHS;
   const StringView InfixOperator;
   const Node *RHS;
 
 public:
   BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_)
       : Node(KBinaryExpr), LHS(LHS_), InfixOperator(InfixOperator_), RHS(RHS_) {
   }
 
   template<typename Fn> void match(Fn F) const { F(LHS, InfixOperator, RHS); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     // might be a template argument expression, then we need to disambiguate
     // with parens.
     if (InfixOperator == ">")
       S += "(";
 
     S += "(";
     LHS->print(S);
     S += ") ";
class ArraySubscriptExpr : public Node {
   const Node *Op2;
 
 public:
   ArraySubscriptExpr(const Node *Op1_, const Node *Op2_)
       : Node(KArraySubscriptExpr), Op1(Op1_), Op2(Op2_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op1, Op2); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "(";
     Op1->print(S);
     S += ")[";
     Op2->print(S);
     S += "]";
   }
 };
 
 class PostfixExpr : public Node {
   const Node *Child;
   const StringView Operator;
 
 public:
   PostfixExpr(const Node *Child_, StringView Operator_)
       : Node(KPostfixExpr), Child(Child_), Operator(Operator_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child, Operator); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "(";
     Child->print(S);
     S += ")";
     S += Operator;
   }
 };
 
 class ConditionalExpr : public Node {
   const Node *Cond;
   const Node *Then;
   const Node *Else;
 
 public:
   ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_)
       : Node(KConditionalExpr), Cond(Cond_), Then(Then_), Else(Else_) {}
 
   template<typename Fn> void match(Fn F) const { F(Cond, Then, Else); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "(";
     Cond->print(S);
     S += ") ? (";
     Then->print(S);
     S += ") : (";
     Else->print(S);
     S += ")";
   }
 };
 
 class MemberExpr : public Node {
   const Node *LHS;
   const StringView Kind;
   const Node *RHS;
 
 public:
   MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_)
       : Node(KMemberExpr), LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
 
   template<typename Fn> void match(Fn F) const { F(LHS, Kind, RHS); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     LHS->print(S);
     S += Kind;
     RHS->print(S);
   }
 };
 
 class SubobjectExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
   StringView Offset;
   NodeArray UnionSelectors;
   bool OnePastTheEnd;
 
 public:
   SubobjectExpr(const Node *Type_, const Node *SubExpr_, StringView Offset_,
                 NodeArray UnionSelectors_, bool OnePastTheEnd_)
       : Node(KSubobjectExpr), Type(Type_), SubExpr(SubExpr_), Offset(Offset_),
         UnionSelectors(UnionSelectors_), OnePastTheEnd(OnePastTheEnd_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(Type, SubExpr, Offset, UnionSelectors, OnePastTheEnd);
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     SubExpr->print(S);
     S += ".<";
     Type->print(S);
     S += " at offset ";
     if (Offset.empty()) {
       S += "0";
     } else if (Offset[0] == 'n') {
       S += "-";

 
 public:
   EnclosingExpr(StringView Prefix_, Node *Infix_, StringView Postfix_)
       : Node(KEnclosingExpr), Prefix(Prefix_), Infix(Infix_),
         Postfix(Postfix_) {}
 
   template<typename Fn> void match(Fn F) const { F(Prefix, Infix, Postfix); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += Prefix;
     Infix->print(S);
     S += Postfix;
   }
 };
 
 class CastExpr : public Node {
   // cast_kind<to>(from)
   const StringView CastKind;
   const Node *To;
   const Node *From;
 
 public:
   CastExpr(StringView CastKind_, const Node *To_, const Node *From_)
       : Node(KCastExpr), CastKind(CastKind_), To(To_), From(From_) {}
 
   template<typename Fn> void match(Fn F) const { F(CastKind, To, From); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += CastKind;
     S += "<";
     To->printLeft(S);
     S += ">(";
     From->printLeft(S);
     S += ")";
   }
 };
 
 class SizeofParamPackExpr : public Node {
   const Node *Pack;
 
 public:
   SizeofParamPackExpr(const Node *Pack_)
       : Node(KSizeofParamPackExpr), Pack(Pack_) {}
 
   template<typename Fn> void match(Fn F) const { F(Pack); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "sizeof...(";
     ParameterPackExpansion PPE(Pack);
     PPE.printLeft(S);
     S += ")";
   }
 };
 
 class CallExpr : public Node {
   const Node *Callee;
   NodeArray Args;
 
 public:
   CallExpr(const Node *Callee_, NodeArray Args_)
       : Node(KCallExpr), Callee(Callee_), Args(Args_) {}
 
   template<typename Fn> void match(Fn F) const { F(Callee, Args); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Callee->print(S);
     S += "(";
     Args.printWithComma(S);
     S += ")";
   }
 };
 
 class NewExpr : public Node {
   // new (expr_list) type(init_list)
   NodeArray ExprList;
   Node *Type;
   NodeArray InitList;
   bool IsGlobal; // ::operator new ?
   bool IsArray;  // new[] ?
 public:
   NewExpr(NodeArray ExprList_, Node *Type_, NodeArray InitList_, bool IsGlobal_,
           bool IsArray_)
       : Node(KNewExpr), ExprList(ExprList_), Type(Type_), InitList(InitList_),
         IsGlobal(IsGlobal_), IsArray(IsArray_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(ExprList, Type, InitList, IsGlobal, IsArray);
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (IsGlobal)
       S += "::operator ";
     S += "new";
     if (IsArray)
       S += "[]";
     S += ' ';
     if (!ExprList.empty()) {
       S += "(";
       ExprList.printWithComma(S);
       S += ")";
     }
     Type->print(S);
     if (!InitList.empty()) {
       S += "(";
       InitList.printWithComma(S);
       S += ")";
     }
 
   }
 };
 
 class DeleteExpr : public Node {
   Node *Op;
   bool IsGlobal;
   bool IsArray;
 
 public:
   DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_)
       : Node(KDeleteExpr), Op(Op_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op, IsGlobal, IsArray); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (IsGlobal)
       S += "::";
     S += "delete";
     if (IsArray)
       S += "[] ";
     Op->print(S);
   }
 };
 
 class PrefixExpr : public Node {
   StringView Prefix;
   Node *Child;
 
 public:
   PrefixExpr(StringView Prefix_, Node *Child_)
       : Node(KPrefixExpr), Prefix(Prefix_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Prefix, Child); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += Prefix;
     S += "(";
     Child->print(S);
     S += ")";
   }
 };
 
 class FunctionParam : public Node {
   StringView Number;
 
 public:
   FunctionParam(StringView Number_) : Node(KFunctionParam), Number(Number_) {}
 
   template<typename Fn> void match(Fn F) const { F(Number); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "fp";
     S += Number;
   }
 };
 
 class ConversionExpr : public Node {
   const Node *Type;
   NodeArray Expressions;
 
 public:
   ConversionExpr(const Node *Type_, NodeArray Expressions_)
       : Node(KConversionExpr), Type(Type_), Expressions(Expressions_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, Expressions); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "(";
     Type->print(S);
     S += ")(";
     Expressions.printWithComma(S);
     S += ")";
   }
 };
 
 class PointerToMemberConversionExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
   StringView Offset;
 
 public:
   PointerToMemberConversionExpr(const Node *Type_, const Node *SubExpr_,
                                 StringView Offset_)
       : Node(KPointerToMemberConversionExpr), Type(Type_), SubExpr(SubExpr_),
         Offset(Offset_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, SubExpr, Offset); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "(";
     Type->print(S);
     S += ")(";
     SubExpr->print(S);
     S += ")";
   }
 };
 
 class InitListExpr : public Node {
   const Node *Ty;
   NodeArray Inits;
 public:
   InitListExpr(const Node *Ty_, NodeArray Inits_)
       : Node(KInitListExpr), Ty(Ty_), Inits(Inits_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Inits); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (Ty)
       Ty->print(S);
     S += '{';
     Inits.printWithComma(S);
     S += '}';
   }
 };
 
 class BracedExpr : public Node {
   const Node *Elem;
   const Node *Init;
   bool IsArray;
 public:
   BracedExpr(const Node *Elem_, const Node *Init_, bool IsArray_)
       : Node(KBracedExpr), Elem(Elem_), Init(Init_), IsArray(IsArray_) {}
 
   template<typename Fn> void match(Fn F) const { F(Elem, Init, IsArray); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (IsArray) {
       S += '[';
       Elem->print(S);
       S += ']';
     } else {
       S += '.';
       Elem->print(S);
     }
     if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
       S += " = ";
     Init->print(S);
   }
 };
 
 class BracedRangeExpr : public Node {
   const Node *First;
   const Node *Last;
   const Node *Init;
 public:
   BracedRangeExpr(const Node *First_, const Node *Last_, const Node *Init_)
       : Node(KBracedRangeExpr), First(First_), Last(Last_), Init(Init_) {}
 
   template<typename Fn> void match(Fn F) const { F(First, Last, Init); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += '[';
     First->print(S);
     S += " ... ";
     Last->print(S);
     S += ']';
     if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
       S += " = ";
     Init->print(S);
FoldExpr(bool IsLeftFold_, StringView OperatorName_, const Node *Pack_,
            const Node *Init_)
       : Node(KFoldExpr), Pack(Pack_), Init(Init_), OperatorName(OperatorName_),
         IsLeftFold(IsLeftFold_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(IsLeftFold, OperatorName, Pack, Init);
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     auto PrintPack = [&] {
       S += '(';
       ParameterPackExpansion(Pack).print(S);
       S += ')';
     };
 
     S += '(';
 

 class ThrowExpr : public Node {
   const Node *Op;
 
 public:
   ThrowExpr(const Node *Op_) : Node(KThrowExpr), Op(Op_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "throw ";
     Op->print(S);
   }
 };
 
 class BoolExpr : public Node {
   bool Value;
 
 public:
   BoolExpr(bool Value_) : Node(KBoolExpr), Value(Value_) {}
 
   template<typename Fn> void match(Fn F) const { F(Value); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += Value ? StringView("true") : StringView("false");
   }
 };
 
 class StringLiteral : public Node {
   const Node *Type;
 
 public:
   StringLiteral(const Node *Type_) : Node(KStringLiteral), Type(Type_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "\"<";
     Type->print(S);
     S += ">\"";
   }
 };
 
 class LambdaExpr : public Node {
   const Node *Type;
 
 public:
   LambdaExpr(const Node *Type_) : Node(KLambdaExpr), Type(Type_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "[]";
     if (Type->getKind() == KClosureTypeName)
       static_cast<const ClosureTypeName *>(Type)->printDeclarator(S);
     S += "{...}";
   }
 };
 
 class EnumLiteral : public Node {
   // ty(integer)
   const Node *Ty;
   StringView Integer;
 
 public:
   EnumLiteral(const Node *Ty_, StringView Integer_)
       : Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Integer); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S << "(";
     Ty->print(S);
     S << ")";
 
     if (Integer[0] == 'n')
       S << "-" << Integer.dropFront(1);
     else
       S << Integer;
   }
 };
 
 class IntegerLiteral : public Node {
   StringView Type;
   StringView Value;
 
 public:
   IntegerLiteral(StringView Type_, StringView Value_)
       : Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, Value); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (Type.size() > 3) {
       S += "(";
       S += Type;
       S += ")";
     }
 
     if (Value[0] == 'n') {
       S += "-";
static constexpr Kind KindForClass =
       float_literal_impl::getFloatLiteralKind((Float *)nullptr);
 
 public:
   FloatLiteralImpl(StringView Contents_)
       : Node(KindForClass), Contents(Contents_) {}
 
   template<typename Fn> void match(Fn F) const { F(Contents); }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     const char *first = Contents.begin();
     const char *last = Contents.end() + 1;
 
     const size_t N = FloatData<Float>::mangled_size;
     if (static_cast<std::size_t>(last - first) > N) {
       last = first + N;
       union {
         Float value;

libcxxabi/src/demangle/Utility.h

 #include <cstring>
 #include <iterator>
 #include <limits>
 
 DEMANGLE_NAMESPACE_BEGIN
 
 // Stream that AST nodes write their string representation into after the AST
 // has been parsed.
-class OutputStream {
+class OutputString {
   char *Buffer = nullptr;
   size_t CurrentPosition = 0;
   size_t BufferCapacity = 0;
 
   // Ensure there is at least n more positions in buffer.
   void grow(size_t N) {
     if (N + CurrentPosition >= BufferCapacity) {
       BufferCapacity *= 2;
void writeUnsigned(uint64_t N, bool isNeg = false) {
 
     // Add negative sign...
     if (isNeg)
       *--TempPtr = '-';
     this->operator<<(StringView(TempPtr, std::end(Temp)));
   }
 
 public:
-  OutputStream(char *StartBuf, size_t Size)
+  OutputString(char *StartBuf, size_t Size)
       : Buffer(StartBuf), CurrentPosition(0), BufferCapacity(Size) {}
-  OutputStream() = default;
+  OutputString() = default;
   void reset(char *Buffer_, size_t BufferCapacity_) {
     CurrentPosition = 0;
     Buffer = Buffer_;
     BufferCapacity = BufferCapacity_;
   }
 
   /// If a ParameterPackExpansion (or similar type) is encountered, the offset
   /// into the pack that we're currently printing.
   unsigned CurrentPackIndex = std::numeric_limits<unsigned>::max();
   unsigned CurrentPackMax = std::numeric_limits<unsigned>::max();
 
-  OutputStream &operator+=(StringView R) {
+  OutputString &operator+=(StringView R) {
     size_t Size = R.size();
     if (Size == 0)
       return *this;
     grow(Size);
     std::memmove(Buffer + CurrentPosition, R.begin(), Size);
     CurrentPosition += Size;
     return *this;
   }
 
-  OutputStream &operator+=(char C) {
+  OutputString &operator+=(char C) {
     grow(1);
     Buffer[CurrentPosition++] = C;
     return *this;
   }
 
-  OutputStream &operator<<(StringView R) { return (*this += R); }
+  OutputString &operator<<(StringView R) { return (*this += R); }
 
-  OutputStream &operator<<(char C) { return (*this += C); }
+  OutputString &operator<<(char C) { return (*this += C); }
 
-  OutputStream &operator<<(long long N) {
+  OutputString &operator<<(long long N) {
     if (N < 0)
       writeUnsigned(static_cast<unsigned long long>(-N), true);
     else
       writeUnsigned(static_cast<unsigned long long>(N));
     return *this;
   }
 
-  OutputStream &operator<<(unsigned long long N) {
+  OutputString &operator<<(unsigned long long N) {
     writeUnsigned(N, false);
     return *this;
   }
 
-  OutputStream &operator<<(long N) {
+  OutputString &operator<<(long N) {
     return this->operator<<(static_cast<long long>(N));
   }
 
-  OutputStream &operator<<(unsigned long N) {
+  OutputString &operator<<(unsigned long N) {
     return this->operator<<(static_cast<unsigned long long>(N));
   }
 
-  OutputStream &operator<<(int N) {
+  OutputString &operator<<(int N) {
     return this->operator<<(static_cast<long long>(N));
   }
 
-  OutputStream &operator<<(unsigned int N) {
+  OutputString &operator<<(unsigned int N) {
     return this->operator<<(static_cast<unsigned long long>(N));
   }
 
   void insert(size_t Pos, const char *S, size_t N) {
     assert(Pos <= CurrentPosition);
     if (N == 0)
       return;
     grow(N);
void restoreNow(bool Force) {
     Restore = std::move(OriginalValue);
     ShouldRestore = false;
   }
 
   SwapAndRestore(const SwapAndRestore &) = delete;
   SwapAndRestore &operator=(const SwapAndRestore &) = delete;
 };
 
-inline bool initializeOutputStream(char *Buf, size_t *N, OutputStream &S,
+inline bool initializeOutputString(char *Buf, size_t *N, OutputString &S,
                                    size_t InitSize) {
   size_t BufferSize;
   if (Buf == nullptr) {
     Buf = static_cast<char *>(std::malloc(InitSize));
     if (Buf == nullptr)
       return false;
     BufferSize = InitSize;
   } else

llvm/include/llvm/Demangle/ItaniumDemangle.h

 //===------------------------- ItaniumDemangle.h ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Generic itanium demangler library. This file has two byte-per-byte identical
 // copies in the source tree, one in libcxxabi, and the other in llvm.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEMANGLE_ITANIUMDEMANGLE_H
 #define LLVM_DEMANGLE_ITANIUMDEMANGLE_H
 
 // FIXME: (possibly) incomplete list of features that clang mangles that this
 // file does not yet support:
 //   - C++ modules TS
 
 #include "DemangleConfig.h"
 #include "StringView.h"
 #include "Utility.h"
public:
   template<typename Fn> void visit(Fn F) const;
 
   // The following function is provided by all derived classes:
   //
   // Call F with arguments that, when passed to the constructor of this node,
   // would construct an equivalent node.
   //template<typename Fn> void match(Fn F) const;
 
-  bool hasRHSComponent(OutputStream &S) const {
+  bool hasRHSComponent(OutputString &S) const {
     if (RHSComponentCache != Cache::Unknown)
       return RHSComponentCache == Cache::Yes;
     return hasRHSComponentSlow(S);
   }
 
-  bool hasArray(OutputStream &S) const {
+  bool hasArray(OutputString &S) const {
     if (ArrayCache != Cache::Unknown)
       return ArrayCache == Cache::Yes;
     return hasArraySlow(S);
   }
 
-  bool hasFunction(OutputStream &S) const {
+  bool hasFunction(OutputString &S) const {
     if (FunctionCache != Cache::Unknown)
       return FunctionCache == Cache::Yes;
     return hasFunctionSlow(S);
   }
 
   Kind getKind() const { return K; }
 
-  virtual bool hasRHSComponentSlow(OutputStream &) const { return false; }
-  virtual bool hasArraySlow(OutputStream &) const { return false; }
-  virtual bool hasFunctionSlow(OutputStream &) const { return false; }
+  virtual bool hasRHSComponentSlow(OutputString &) const { return false; }
+  virtual bool hasArraySlow(OutputString &) const { return false; }
+  virtual bool hasFunctionSlow(OutputString &) const { return false; }
 
   // Dig through "glue" nodes like ParameterPack and ForwardTemplateReference to
   // get at a node that actually represents some concrete syntax.
-  virtual const Node *getSyntaxNode(OutputStream &) const {
+  virtual const Node *getSyntaxNode(OutputString &) const {
     return this;
   }
 
-  void print(OutputStream &S) const {
+  void print(OutputString &S) const {
     printLeft(S);
     if (RHSComponentCache != Cache::No)
       printRight(S);
   }
 
-  // Print the "left" side of this Node into OutputStream.
-  virtual void printLeft(OutputStream &) const = 0;
+  // Print the "left" side of this Node into OutputString.
+  virtual void printLeft(OutputString &) const = 0;
 
   // Print the "right". This distinction is necessary to represent C++ types
   // that appear on the RHS of their subtype, such as arrays or functions.
   // Since most types don't have such a component, provide a default
   // implementation.
-  virtual void printRight(OutputStream &) const {}
+  virtual void printRight(OutputString &) const {}
 
   virtual StringView getBaseName() const { return StringView(); }
 
   // Silence compiler warnings, this dtor will never be called.
   virtual ~Node() = default;
 
 #ifndef NDEBUG
   DEMANGLE_DUMP_METHOD void dump() const;
public:
   bool empty() const { return NumElements == 0; }
   size_t size() const { return NumElements; }
 
   Node **begin() const { return Elements; }
   Node **end() const { return Elements + NumElements; }
 
   Node *operator[](size_t Idx) const { return Elements[Idx]; }
 
-  void printWithComma(OutputStream &S) const {
+  void printWithComma(OutputString &S) const {
     bool FirstElement = true;
     for (size_t Idx = 0; Idx != NumElements; ++Idx) {
       size_t BeforeComma = S.getCurrentPosition();
       if (!FirstElement)
         S += ", ";
       size_t AfterComma = S.getCurrentPosition();
       Elements[Idx]->print(S);
 

 };
 
 struct NodeArrayNode : Node {
   NodeArray Array;
   NodeArrayNode(NodeArray Array_) : Node(KNodeArrayNode), Array(Array_) {}
 
   template<typename Fn> void match(Fn F) const { F(Array); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Array.printWithComma(S);
   }
 };
 
 class DotSuffix final : public Node {
   const Node *Prefix;
   const StringView Suffix;
 
 public:
   DotSuffix(const Node *Prefix_, StringView Suffix_)
       : Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
 
   template<typename Fn> void match(Fn F) const { F(Prefix, Suffix); }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     Prefix->print(s);
     s += " (";
     s += Suffix;
     s += ")";
   }
 };
 
 class VendorExtQualType final : public Node {
   const Node *Ty;
   StringView Ext;
   const Node *TA;
 
 public:
   VendorExtQualType(const Node *Ty_, StringView Ext_, const Node *TA_)
       : Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {}
 
   template <typename Fn> void match(Fn F) const { F(Ty, Ext, TA); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Ty->print(S);
     S += " ";
     S += Ext;
     if (TA != nullptr)
       TA->print(S);
   }
 };
 
inline Qualifiers operator|=(Qualifiers &Q1, Qualifiers Q2) {
   return Q1 = static_cast<Qualifiers>(Q1 | Q2);
 }
 
 class QualType final : public Node {
 protected:
   const Qualifiers Quals;
   const Node *Child;
 
-  void printQuals(OutputStream &S) const {
+  void printQuals(OutputString &S) const {
     if (Quals & QualConst)
       S += " const";
     if (Quals & QualVolatile)
       S += " volatile";
     if (Quals & QualRestrict)
       S += " restrict";
   }
 
 public:
   QualType(const Node *Child_, Qualifiers Quals_)
       : Node(KQualType, Child_->RHSComponentCache,
              Child_->ArrayCache, Child_->FunctionCache),
         Quals(Quals_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child, Quals); }
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     return Child->hasRHSComponent(S);
   }
-  bool hasArraySlow(OutputStream &S) const override {
+  bool hasArraySlow(OutputString &S) const override {
     return Child->hasArray(S);
   }
-  bool hasFunctionSlow(OutputStream &S) const override {
+  bool hasFunctionSlow(OutputString &S) const override {
     return Child->hasFunction(S);
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Child->printLeft(S);
     printQuals(S);
   }
 
-  void printRight(OutputStream &S) const override { Child->printRight(S); }
+  void printRight(OutputString &S) const override { Child->printRight(S); }
 };
 
 class ConversionOperatorType final : public Node {
   const Node *Ty;
 
 public:
   ConversionOperatorType(const Node *Ty_)
       : Node(KConversionOperatorType), Ty(Ty_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "operator ";
     Ty->print(S);
   }
 };
 
 class PostfixQualifiedType final : public Node {
   const Node *Ty;
   const StringView Postfix;
 
 public:
   PostfixQualifiedType(Node *Ty_, StringView Postfix_)
       : Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Postfix); }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     Ty->printLeft(s);
     s += Postfix;
   }
 };
 
 class NameType final : public Node {
   const StringView Name;
 
 public:
   NameType(StringView Name_) : Node(KNameType), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name); }
 
   StringView getName() const { return Name; }
   StringView getBaseName() const override { return Name; }
 
-  void printLeft(OutputStream &s) const override { s += Name; }
+  void printLeft(OutputString &s) const override { s += Name; }
 };
 
 class ElaboratedTypeSpefType : public Node {
   StringView Kind;
   Node *Child;
 public:
   ElaboratedTypeSpefType(StringView Kind_, Node *Child_)
       : Node(KElaboratedTypeSpefType), Kind(Kind_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Kind, Child); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += Kind;
     S += ' ';
     Child->print(S);
   }
 };
 
 struct AbiTagAttr : Node {
   Node *Base;
   StringView Tag;
 
   AbiTagAttr(Node* Base_, StringView Tag_)
       : Node(KAbiTagAttr, Base_->RHSComponentCache,
              Base_->ArrayCache, Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
 
   template<typename Fn> void match(Fn F) const { F(Base, Tag); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Base->printLeft(S);
     S += "[abi:";
     S += Tag;
     S += "]";
   }
 };
 
 class EnableIfAttr : public Node {
   NodeArray Conditions;
 public:
   EnableIfAttr(NodeArray Conditions_)
       : Node(KEnableIfAttr), Conditions(Conditions_) {}
 
   template<typename Fn> void match(Fn F) const { F(Conditions); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += " [enable_if:";
     Conditions.printWithComma(S);
     S += ']';
   }
 };
 
 class ObjCProtoName : public Node {
   const Node *Ty;
   StringView Protocol;
 
   friend class PointerType;
 
 public:
   ObjCProtoName(const Node *Ty_, StringView Protocol_)
       : Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Protocol); }
 
   bool isObjCObject() const {
     return Ty->getKind() == KNameType &&
            static_cast<const NameType *>(Ty)->getName() == "objc_object";
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Ty->print(S);
     S += "<";
     S += Protocol;
     S += ">";
   }
 };
 
 class PointerType final : public Node {
   const Node *Pointee;
 
 public:
   PointerType(const Node *Pointee_)
       : Node(KPointerType, Pointee_->RHSComponentCache),
         Pointee(Pointee_) {}
 
   template<typename Fn> void match(Fn F) const { F(Pointee); }
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     return Pointee->hasRHSComponent(S);
   }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     // We rewrite objc_object<SomeProtocol>* into id<SomeProtocol>.
     if (Pointee->getKind() != KObjCProtoName ||
         !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
       Pointee->printLeft(s);
       if (Pointee->hasArray(s))
         s += " ";
       if (Pointee->hasArray(s) || Pointee->hasFunction(s))
         s += "(";
       s += "*";
     } else {
       const auto *objcProto = static_cast<const ObjCProtoName *>(Pointee);
       s += "id<";
       s += objcProto->Protocol;
       s += ">";
     }
   }
 
-  void printRight(OutputStream &s) const override {
+  void printRight(OutputString &s) const override {
     if (Pointee->getKind() != KObjCProtoName ||
         !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
       if (Pointee->hasArray(s) || Pointee->hasFunction(s))
         s += ")";
       Pointee->printRight(s);
     }
   }
 };
class ReferenceType : public Node {
 
   // Dig through any refs to refs, collapsing the ReferenceTypes as we go. The
   // rule here is rvalue ref to rvalue ref collapses to a rvalue ref, and any
   // other combination collapses to a lvalue ref.
   //
   // A combination of a TemplateForwardReference and a back-ref Substitution
   // from an ill-formed string may have created a cycle; use cycle detection to
   // avoid looping forever.
-  std::pair<ReferenceKind, const Node *> collapse(OutputStream &S) const {
+  std::pair<ReferenceKind, const Node *> collapse(OutputString &S) const {
     auto SoFar = std::make_pair(RK, Pointee);
     // Track the chain of nodes for the Floyd's 'tortoise and hare'
     // cycle-detection algorithm, since getSyntaxNode(S) is impure
     PODSmallVector<const Node *, 8> Prev;
     for (;;) {
       const Node *SN = SoFar.second->getSyntaxNode(S);
       if (SN->getKind() != KReferenceType)
         break;
       auto *RT = static_cast<const ReferenceType *>(SN);
       SoFar.second = RT->Pointee;
       SoFar.first = std::min(SoFar.first, RT->RK);
 
-      // The middle of `Prev` is the 'slow' pointer moving at half speed
+      // The middle of Prev is the 'slow' pointer moving at half speed
       Prev.push_back(SoFar.second);
       if (Prev.size() > 1 && SoFar.second == Prev[(Prev.size() - 1) / 2]) {
         // Cycle detected
         SoFar.second = nullptr;
         break;
       }
     }
     return SoFar;
   }
 
 public:
   ReferenceType(const Node *Pointee_, ReferenceKind RK_)
       : Node(KReferenceType, Pointee_->RHSComponentCache),
         Pointee(Pointee_), RK(RK_) {}
 
   template<typename Fn> void match(Fn F) const { F(Pointee, RK); }
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     return Pointee->hasRHSComponent(S);
   }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     if (Printing)
       return;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     std::pair<ReferenceKind, const Node *> Collapsed = collapse(s);
     if (!Collapsed.second)
       return;
     Collapsed.second->printLeft(s);
     if (Collapsed.second->hasArray(s))
       s += " ";
     if (Collapsed.second->hasArray(s) || Collapsed.second->hasFunction(s))
       s += "(";
 
     s += (Collapsed.first == ReferenceKind::LValue ? "&" : "&&");
   }
-  void printRight(OutputStream &s) const override {
+  void printRight(OutputString &s) const override {
     if (Printing)
       return;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     std::pair<ReferenceKind, const Node *> Collapsed = collapse(s);
     if (!Collapsed.second)
       return;
     if (Collapsed.second->hasArray(s) || Collapsed.second->hasFunction(s))
       s += ")";
     Collapsed.second->printRight(s);
   }
 };
 
 class PointerToMemberType final : public Node {
   const Node *ClassType;
   const Node *MemberType;
 
 public:
   PointerToMemberType(const Node *ClassType_, const Node *MemberType_)
       : Node(KPointerToMemberType, MemberType_->RHSComponentCache),
         ClassType(ClassType_), MemberType(MemberType_) {}
 
   template<typename Fn> void match(Fn F) const { F(ClassType, MemberType); }
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     return MemberType->hasRHSComponent(S);
   }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     MemberType->printLeft(s);
     if (MemberType->hasArray(s) || MemberType->hasFunction(s))
       s += "(";
     else
       s += " ";
     ClassType->print(s);
     s += "::*";
   }
 
-  void printRight(OutputStream &s) const override {
+  void printRight(OutputString &s) const override {
     if (MemberType->hasArray(s) || MemberType->hasFunction(s))
       s += ")";
     MemberType->printRight(s);
   }
 };
 
 class ArrayType final : public Node {
   const Node *Base;
   Node *Dimension;
 
 public:
   ArrayType(const Node *Base_, Node *Dimension_)
       : Node(KArrayType,
              /*RHSComponentCache=*/Cache::Yes,
              /*ArrayCache=*/Cache::Yes),
         Base(Base_), Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(Base, Dimension); }
 
-  bool hasRHSComponentSlow(OutputStream &) const override { return true; }
-  bool hasArraySlow(OutputStream &) const override { return true; }
+  bool hasRHSComponentSlow(OutputString &) const override { return true; }
+  bool hasArraySlow(OutputString &) const override { return true; }
 
-  void printLeft(OutputStream &S) const override { Base->printLeft(S); }
+  void printLeft(OutputString &S) const override { Base->printLeft(S); }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     if (S.back() != ']')
       S += " ";
     S += "[";
     if (Dimension)
       Dimension->print(S);
     S += "]";
     Base->printRight(S);
   }
FunctionType(const Node *Ret_, NodeArray Params_, Qualifiers CVQuals_,
              /*FunctionCache=*/Cache::Yes),
         Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_),
         ExceptionSpec(ExceptionSpec_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(Ret, Params, CVQuals, RefQual, ExceptionSpec);
   }
 
-  bool hasRHSComponentSlow(OutputStream &) const override { return true; }
-  bool hasFunctionSlow(OutputStream &) const override { return true; }
+  bool hasRHSComponentSlow(OutputString &) const override { return true; }
+  bool hasFunctionSlow(OutputString &) const override { return true; }
 
   // Handle C++'s ... quirky decl grammar by using the left & right
   // distinction. Consider:
   //   int (*f(float))(char) {}
   // f is a function that takes a float and returns a pointer to a function
   // that takes a char and returns an int. If we're trying to print f, start
   // by printing out the return types's left, then print our parameters, then
   // finally print right of the return type.
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Ret->printLeft(S);
     S += " ";
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     S += "(";
     Params.printWithComma(S);
     S += ")";
     Ret->printRight(S);
 
     if (CVQuals & QualConst)
       S += " const";
     if (CVQuals & QualVolatile)

 
 class NoexceptSpec : public Node {
   const Node *E;
 public:
   NoexceptSpec(const Node *E_) : Node(KNoexceptSpec), E(E_) {}
 
   template<typename Fn> void match(Fn F) const { F(E); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "noexcept(";
     E->print(S);
     S += ")";
   }
 };
 
 class DynamicExceptionSpec : public Node {
   NodeArray Types;
 public:
   DynamicExceptionSpec(NodeArray Types_)
       : Node(KDynamicExceptionSpec), Types(Types_) {}
 
   template<typename Fn> void match(Fn F) const { F(Types); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "throw(";
     Types.printWithComma(S);
     S += ')';
   }
 };
 
 class FunctionEncoding final : public Node {
   const Node *Ret;
template<typename Fn> void match(Fn F) const {
     F(Ret, Name, Params, Attrs, CVQuals, RefQual);
   }
 
   Qualifiers getCVQuals() const { return CVQuals; }
   FunctionRefQual getRefQual() const { return RefQual; }
   NodeArray getParams() const { return Params; }
   const Node *getReturnType() const { return Ret; }
 
-  bool hasRHSComponentSlow(OutputStream &) const override { return true; }
-  bool hasFunctionSlow(OutputStream &) const override { return true; }
+  bool hasRHSComponentSlow(OutputString &) const override { return true; }
+  bool hasFunctionSlow(OutputString &) const override { return true; }
 
   const Node *getName() const { return Name; }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (Ret) {
       Ret->printLeft(S);
       if (!Ret->hasRHSComponent(S))
         S += " ";
     }
     Name->print(S);
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     S += "(";
     Params.printWithComma(S);
     S += ")";
     if (Ret)
       Ret->printRight(S);
 
     if (CVQuals & QualConst)
       S += " const";
class LiteralOperator : public Node {
   const Node *OpName;
 
 public:
   LiteralOperator(const Node *OpName_)
       : Node(KLiteralOperator), OpName(OpName_) {}
 
   template<typename Fn> void match(Fn F) const { F(OpName); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "operator\"\" ";
     OpName->print(S);
   }
 };
 
 class SpecialName final : public Node {
   const StringView Special;
   const Node *Child;
 
 public:
   SpecialName(StringView Special_, const Node *Child_)
       : Node(KSpecialName), Special(Special_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Special, Child); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += Special;
     Child->print(S);
   }
 };
 
 class CtorVtableSpecialName final : public Node {
   const Node *FirstType;
   const Node *SecondType;
 
 public:
   CtorVtableSpecialName(const Node *FirstType_, const Node *SecondType_)
       : Node(KCtorVtableSpecialName),
         FirstType(FirstType_), SecondType(SecondType_) {}
 
   template<typename Fn> void match(Fn F) const { F(FirstType, SecondType); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "construction vtable for ";
     FirstType->print(S);
     S += "-in-";
     SecondType->print(S);
   }
 };
 
 struct NestedName : Node {
   Node *Qual;
   Node *Name;
 
   NestedName(Node *Qual_, Node *Name_)
       : Node(KNestedName), Qual(Qual_), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Qual, Name); }
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Qual->print(S);
     S += "::";
     Name->print(S);
   }
 };
 
 struct LocalName : Node {
   Node *Encoding;
   Node *Entity;
 
   LocalName(Node *Encoding_, Node *Entity_)
       : Node(KLocalName), Encoding(Encoding_), Entity(Entity_) {}
 
   template<typename Fn> void match(Fn F) const { F(Encoding, Entity); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Encoding->print(S);
     S += "::";
     Entity->print(S);
   }
 };
 
 class QualifiedName final : public Node {
   // qualifier::name
   const Node *Qualifier;
   const Node *Name;
 
 public:
   QualifiedName(const Node *Qualifier_, const Node *Name_)
       : Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Qualifier, Name); }
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Qualifier->print(S);
     S += "::";
     Name->print(S);
   }
 };
 
 class VectorType final : public Node {
   const Node *BaseType;
   const Node *Dimension;
 
 public:
   VectorType(const Node *BaseType_, Node *Dimension_)
       : Node(KVectorType), BaseType(BaseType_),
         Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(BaseType, Dimension); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     BaseType->print(S);
     S += " vector[";
     if (Dimension)
       Dimension->print(S);
     S += "]";
   }
 };
 
 class PixelVectorType final : public Node {
   const Node *Dimension;
 
 public:
   PixelVectorType(const Node *Dimension_)
       : Node(KPixelVectorType), Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(Dimension); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     // FIXME: This should demangle as "vector pixel".
     S += "pixel vector[";
     Dimension->print(S);
     S += "]";
   }
 };
 
 class BinaryFPType final : public Node {
   const Node *Dimension;
 
 public:
   BinaryFPType(const Node *Dimension_)
       : Node(KBinaryFPType), Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(Dimension); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "_Float";
     Dimension->print(S);
   }
 };
 
 enum class TemplateParamKind { Type, NonType, Template };
 
 /// An invented name for a template parameter for which we don't have a
 /// corresponding template argument.
 ///
 /// This node is created when parsing the <lambda-sig> for a lambda with
 /// explicit template arguments, which might be referenced in the parameter
 /// types appearing later in the <lambda-sig>.
 class SyntheticTemplateParamName final : public Node {
   TemplateParamKind Kind;
   unsigned Index;
 
 public:
   SyntheticTemplateParamName(TemplateParamKind Kind_, unsigned Index_)
       : Node(KSyntheticTemplateParamName), Kind(Kind_), Index(Index_) {}
 
   template<typename Fn> void match(Fn F) const { F(Kind, Index); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     switch (Kind) {
     case TemplateParamKind::Type:
       S += "$T";
       break;
     case TemplateParamKind::NonType:
       S += "$N";
       break;
     case TemplateParamKind::Template:
class TypeTemplateParamDecl final : public Node {
   Node *Name;
 
 public:
   TypeTemplateParamDecl(Node *Name_)
       : Node(KTypeTemplateParamDecl, Cache::Yes), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "typename ";
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     Name->print(S);
   }
 };
 
 /// A non-type template parameter declaration, 'int N'.
 class NonTypeTemplateParamDecl final : public Node {
   Node *Name;
   Node *Type;
 
 public:
   NonTypeTemplateParamDecl(Node *Name_, Node *Type_)
       : Node(KNonTypeTemplateParamDecl, Cache::Yes), Name(Name_), Type(Type_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, Type); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Type->printLeft(S);
     if (!Type->hasRHSComponent(S))
       S += " ";
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     Name->print(S);
     Type->printRight(S);
   }
 };
 
 /// A template template parameter declaration,
 /// 'template<typename T> typename N'.
 class TemplateTemplateParamDecl final : public Node {
   Node *Name;
   NodeArray Params;
 
 public:
   TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
       : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
         Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, Params); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "template<";
     Params.printWithComma(S);
     S += "> typename ";
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     Name->print(S);
   }
 };
 
 /// A template parameter pack declaration, 'typename ...T'.
 class TemplateParamPackDecl final : public Node {
   Node *Param;
 
 public:
   TemplateParamPackDecl(Node *Param_)
       : Node(KTemplateParamPackDecl, Cache::Yes), Param(Param_) {}
 
   template<typename Fn> void match(Fn F) const { F(Param); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Param->printLeft(S);
     S += "...";
   }
 
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     Param->printRight(S);
   }
 };
 
 /// An unexpanded parameter pack (either in the expression or type context). If
 /// this AST is correct, this node will have a ParameterPackExpansion node above
 /// it.
 ///
 /// This node is created when some <template-args> are found that apply to an
 /// <encoding>, and is stored in the TemplateParams table. In order for this to
 /// appear in the final AST, it has to referenced via a <template-param> (ie,
 /// T_).
 class ParameterPack final : public Node {
   NodeArray Data;
 
-  // Setup OutputStream for a pack expansion unless we're already expanding one.
-  void initializePackExpansion(OutputStream &S) const {
+  // Setup OutputString for a pack expansion unless we're already expanding one.
+  void initializePackExpansion(OutputString &S) const {
     if (S.CurrentPackMax == std::numeric_limits<unsigned>::max()) {
       S.CurrentPackMax = static_cast<unsigned>(Data.size());
       S.CurrentPackIndex = 0;
     }
   }
 
 public:
   ParameterPack(NodeArray Data_) : Node(KParameterPack), Data(Data_) {
ParameterPack(NodeArray Data_) : Node(KParameterPack), Data(Data_) {
     if (std::all_of(Data.begin(), Data.end(), [](Node* P) {
           return P->RHSComponentCache == Cache::No;
         }))
       RHSComponentCache = Cache::No;
   }
 
   template<typename Fn> void match(Fn F) const { F(Data); }
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     return Idx < Data.size() && Data[Idx]->hasRHSComponent(S);
   }
-  bool hasArraySlow(OutputStream &S) const override {
+  bool hasArraySlow(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     return Idx < Data.size() && Data[Idx]->hasArray(S);
   }
-  bool hasFunctionSlow(OutputStream &S) const override {
+  bool hasFunctionSlow(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     return Idx < Data.size() && Data[Idx]->hasFunction(S);
   }
-  const Node *getSyntaxNode(OutputStream &S) const override {
+  const Node *getSyntaxNode(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     return Idx < Data.size() ? Data[Idx]->getSyntaxNode(S) : this;
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     if (Idx < Data.size())
       Data[Idx]->printLeft(S);
   }
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     if (Idx < Data.size())
       Data[Idx]->printRight(S);
   }
 };
 
 /// A variadic template argument. This node represents an occurrence of
 /// J<something>E in some <template-args>. It isn't itself unexpanded, unless
 /// one of it's Elements is. The parser inserts a ParameterPack into the
 /// TemplateParams table if the <template-args> this pack belongs to apply to an
 /// <encoding>.
 class TemplateArgumentPack final : public Node {
   NodeArray Elements;
 public:
   TemplateArgumentPack(NodeArray Elements_)
       : Node(KTemplateArgumentPack), Elements(Elements_) {}
 
   template<typename Fn> void match(Fn F) const { F(Elements); }
 
   NodeArray getElements() const { return Elements; }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Elements.printWithComma(S);
   }
 };
 
 /// A pack expansion. Below this node, there are some unexpanded ParameterPacks
 /// which each have Child->ParameterPackSize elements.
 class ParameterPackExpansion final : public Node {
   const Node *Child;
 
 public:
   ParameterPackExpansion(const Node *Child_)
       : Node(KParameterPackExpansion), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child); }
 
   const Node *getChild() const { return Child; }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     constexpr unsigned Max = std::numeric_limits<unsigned>::max();
     SwapAndRestore<unsigned> SavePackIdx(S.CurrentPackIndex, Max);
     SwapAndRestore<unsigned> SavePackMax(S.CurrentPackMax, Max);
     size_t StreamPos = S.getCurrentPosition();
 
     // Print the first element in the pack. If Child contains a ParameterPack,
     // it will set up S.CurrentPackMax and print the first element.
     Child->print(S);

 
 public:
   TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Params); }
 
   NodeArray getParams() { return Params; }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "<";
     Params.printWithComma(S);
     if (S.back() == '>')
       S += " ";
     S += ">";
   }
 };
 
ForwardTemplateReference(size_t Index_)
              Cache::Unknown),
         Index(Index_) {}
 
   // We don't provide a matcher for these, because the value of the node is
   // not determined by its construction parameters, and it generally needs
   // special handling.
   template<typename Fn> void match(Fn F) const = delete;
 
-  bool hasRHSComponentSlow(OutputStream &S) const override {
+  bool hasRHSComponentSlow(OutputString &S) const override {
     if (Printing)
       return false;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     return Ref->hasRHSComponent(S);
   }
-  bool hasArraySlow(OutputStream &S) const override {
+  bool hasArraySlow(OutputString &S) const override {
     if (Printing)
       return false;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     return Ref->hasArray(S);
   }
-  bool hasFunctionSlow(OutputStream &S) const override {
+  bool hasFunctionSlow(OutputString &S) const override {
     if (Printing)
       return false;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     return Ref->hasFunction(S);
   }
-  const Node *getSyntaxNode(OutputStream &S) const override {
+  const Node *getSyntaxNode(OutputString &S) const override {
     if (Printing)
       return this;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     return Ref->getSyntaxNode(S);
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (Printing)
       return;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     Ref->printLeft(S);
   }
-  void printRight(OutputStream &S) const override {
+  void printRight(OutputString &S) const override {
     if (Printing)
       return;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     Ref->printRight(S);
   }
 };
 
 struct NameWithTemplateArgs : Node {
   // name<template_args>
   Node *Name;
   Node *TemplateArgs;
 
   NameWithTemplateArgs(Node *Name_, Node *TemplateArgs_)
       : Node(KNameWithTemplateArgs), Name(Name_), TemplateArgs(TemplateArgs_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, TemplateArgs); }
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Name->print(S);
     TemplateArgs->print(S);
   }
 };
 
 class GlobalQualifiedName final : public Node {
   Node *Child;
 
 public:
   GlobalQualifiedName(Node* Child_)
       : Node(KGlobalQualifiedName), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child); }
 
   StringView getBaseName() const override { return Child->getBaseName(); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "::";
     Child->print(S);
   }
 };
 
 struct StdQualifiedName : Node {
   Node *Child;
 
   StdQualifiedName(Node *Child_) : Node(KStdQualifiedName), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child); }
 
   StringView getBaseName() const override { return Child->getBaseName(); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "std::";
     Child->print(S);
   }
 };
 
 enum class SpecialSubKind {
   allocator,
   basic_string,
StringView getBaseName() const override {
     case SpecialSubKind::ostream:
       return StringView("basic_ostream");
     case SpecialSubKind::iostream:
       return StringView("basic_iostream");
     }
     DEMANGLE_UNREACHABLE;
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     switch (SSK) {
     case SpecialSubKind::allocator:
       S += "std::allocator";
       break;
     case SpecialSubKind::basic_string:
       S += "std::basic_string";
       break;
     case SpecialSubKind::string:
StringView getBaseName() const override {
     case SpecialSubKind::ostream:
       return StringView("ostream");
     case SpecialSubKind::iostream:
       return StringView("iostream");
     }
     DEMANGLE_UNREACHABLE;
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     switch (SSK) {
     case SpecialSubKind::allocator:
       S += "std::allocator";
       break;
     case SpecialSubKind::basic_string:
       S += "std::basic_string";
       break;
     case SpecialSubKind::string:

 
 public:
   CtorDtorName(const Node *Basename_, bool IsDtor_, int Variant_)
       : Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_),
         Variant(Variant_) {}
 
   template<typename Fn> void match(Fn F) const { F(Basename, IsDtor, Variant); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (IsDtor)
       S += "~";
     S += Basename->getBaseName();
   }
 };
 
 class DtorName : public Node {
   const Node *Base;
 
 public:
   DtorName(const Node *Base_) : Node(KDtorName), Base(Base_) {}
 
   template<typename Fn> void match(Fn F) const { F(Base); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "~";
     Base->printLeft(S);
   }
 };
 
 class UnnamedTypeName : public Node {
   const StringView Count;
 
 public:
   UnnamedTypeName(StringView Count_) : Node(KUnnamedTypeName), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const { F(Count); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "'unnamed";
     S += Count;
     S += "\'";
   }
 };
 
 class ClosureTypeName : public Node {
   NodeArray TemplateParams;
   NodeArray Params;
   StringView Count;
 
 public:
   ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
                   StringView Count_)
       : Node(KClosureTypeName), TemplateParams(TemplateParams_),
         Params(Params_), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(TemplateParams, Params, Count);
   }
 
-  void printDeclarator(OutputStream &S) const {
+  void printDeclarator(OutputString &S) const {
     if (!TemplateParams.empty()) {
       S += "<";
       TemplateParams.printWithComma(S);
       S += ">";
     }
     S += "(";
     Params.printWithComma(S);
     S += ")";
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "\'lambda";
     S += Count;
     S += "\'";
     printDeclarator(S);
   }
 };
 
 class StructuredBindingName : public Node {
   NodeArray Bindings;
 public:
   StructuredBindingName(NodeArray Bindings_)
       : Node(KStructuredBindingName), Bindings(Bindings_) {}
 
   template<typename Fn> void match(Fn F) const { F(Bindings); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += '[';
     Bindings.printWithComma(S);
     S += ']';
   }
 };
 
 // -- Expression Nodes --
 
 class BinaryExpr : public Node {
   const Node *LHS;
   const StringView InfixOperator;
   const Node *RHS;
 
 public:
   BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_)
       : Node(KBinaryExpr), LHS(LHS_), InfixOperator(InfixOperator_), RHS(RHS_) {
   }
 
   template<typename Fn> void match(Fn F) const { F(LHS, InfixOperator, RHS); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     // might be a template argument expression, then we need to disambiguate
     // with parens.
     if (InfixOperator == ">")
       S += "(";
 
     S += "(";
     LHS->print(S);
     S += ") ";
class ArraySubscriptExpr : public Node {
   const Node *Op2;
 
 public:
   ArraySubscriptExpr(const Node *Op1_, const Node *Op2_)
       : Node(KArraySubscriptExpr), Op1(Op1_), Op2(Op2_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op1, Op2); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "(";
     Op1->print(S);
     S += ")[";
     Op2->print(S);
     S += "]";
   }
 };
 
 class PostfixExpr : public Node {
   const Node *Child;
   const StringView Operator;
 
 public:
   PostfixExpr(const Node *Child_, StringView Operator_)
       : Node(KPostfixExpr), Child(Child_), Operator(Operator_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child, Operator); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "(";
     Child->print(S);
     S += ")";
     S += Operator;
   }
 };
 
 class ConditionalExpr : public Node {
   const Node *Cond;
   const Node *Then;
   const Node *Else;
 
 public:
   ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_)
       : Node(KConditionalExpr), Cond(Cond_), Then(Then_), Else(Else_) {}
 
   template<typename Fn> void match(Fn F) const { F(Cond, Then, Else); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "(";
     Cond->print(S);
     S += ") ? (";
     Then->print(S);
     S += ") : (";
     Else->print(S);
     S += ")";
   }
 };
 
 class MemberExpr : public Node {
   const Node *LHS;
   const StringView Kind;
   const Node *RHS;
 
 public:
   MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_)
       : Node(KMemberExpr), LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
 
   template<typename Fn> void match(Fn F) const { F(LHS, Kind, RHS); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     LHS->print(S);
     S += Kind;
     RHS->print(S);
   }
 };
 
 class SubobjectExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
   StringView Offset;
   NodeArray UnionSelectors;
   bool OnePastTheEnd;
 
 public:
   SubobjectExpr(const Node *Type_, const Node *SubExpr_, StringView Offset_,
                 NodeArray UnionSelectors_, bool OnePastTheEnd_)
       : Node(KSubobjectExpr), Type(Type_), SubExpr(SubExpr_), Offset(Offset_),
         UnionSelectors(UnionSelectors_), OnePastTheEnd(OnePastTheEnd_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(Type, SubExpr, Offset, UnionSelectors, OnePastTheEnd);
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     SubExpr->print(S);
     S += ".<";
     Type->print(S);
     S += " at offset ";
     if (Offset.empty()) {
       S += "0";
     } else if (Offset[0] == 'n') {
       S += "-";

 
 public:
   EnclosingExpr(StringView Prefix_, Node *Infix_, StringView Postfix_)
       : Node(KEnclosingExpr), Prefix(Prefix_), Infix(Infix_),
         Postfix(Postfix_) {}
 
   template<typename Fn> void match(Fn F) const { F(Prefix, Infix, Postfix); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += Prefix;
     Infix->print(S);
     S += Postfix;
   }
 };
 
 class CastExpr : public Node {
   // cast_kind<to>(from)
   const StringView CastKind;
   const Node *To;
   const Node *From;
 
 public:
   CastExpr(StringView CastKind_, const Node *To_, const Node *From_)
       : Node(KCastExpr), CastKind(CastKind_), To(To_), From(From_) {}
 
   template<typename Fn> void match(Fn F) const { F(CastKind, To, From); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += CastKind;
     S += "<";
     To->printLeft(S);
     S += ">(";
     From->printLeft(S);
     S += ")";
   }
 };
 
 class SizeofParamPackExpr : public Node {
   const Node *Pack;
 
 public:
   SizeofParamPackExpr(const Node *Pack_)
       : Node(KSizeofParamPackExpr), Pack(Pack_) {}
 
   template<typename Fn> void match(Fn F) const { F(Pack); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "sizeof...(";
     ParameterPackExpansion PPE(Pack);
     PPE.printLeft(S);
     S += ")";
   }
 };
 
 class CallExpr : public Node {
   const Node *Callee;
   NodeArray Args;
 
 public:
   CallExpr(const Node *Callee_, NodeArray Args_)
       : Node(KCallExpr), Callee(Callee_), Args(Args_) {}
 
   template<typename Fn> void match(Fn F) const { F(Callee, Args); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     Callee->print(S);
     S += "(";
     Args.printWithComma(S);
     S += ")";
   }
 };
 
 class NewExpr : public Node {
   // new (expr_list) type(init_list)
   NodeArray ExprList;
   Node *Type;
   NodeArray InitList;
   bool IsGlobal; // ::operator new ?
   bool IsArray;  // new[] ?
 public:
   NewExpr(NodeArray ExprList_, Node *Type_, NodeArray InitList_, bool IsGlobal_,
           bool IsArray_)
       : Node(KNewExpr), ExprList(ExprList_), Type(Type_), InitList(InitList_),
         IsGlobal(IsGlobal_), IsArray(IsArray_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(ExprList, Type, InitList, IsGlobal, IsArray);
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (IsGlobal)
       S += "::operator ";
     S += "new";
     if (IsArray)
       S += "[]";
     S += ' ';
     if (!ExprList.empty()) {
       S += "(";
       ExprList.printWithComma(S);
       S += ")";
     }
     Type->print(S);
     if (!InitList.empty()) {
       S += "(";
       InitList.printWithComma(S);
       S += ")";
     }
 
   }
 };
 
 class DeleteExpr : public Node {
   Node *Op;
   bool IsGlobal;
   bool IsArray;
 
 public:
   DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_)
       : Node(KDeleteExpr), Op(Op_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op, IsGlobal, IsArray); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (IsGlobal)
       S += "::";
     S += "delete";
     if (IsArray)
       S += "[] ";
     Op->print(S);
   }
 };
 
 class PrefixExpr : public Node {
   StringView Prefix;
   Node *Child;
 
 public:
   PrefixExpr(StringView Prefix_, Node *Child_)
       : Node(KPrefixExpr), Prefix(Prefix_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Prefix, Child); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += Prefix;
     S += "(";
     Child->print(S);
     S += ")";
   }
 };
 
 class FunctionParam : public Node {
   StringView Number;
 
 public:
   FunctionParam(StringView Number_) : Node(KFunctionParam), Number(Number_) {}
 
   template<typename Fn> void match(Fn F) const { F(Number); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "fp";
     S += Number;
   }
 };
 
 class ConversionExpr : public Node {
   const Node *Type;
   NodeArray Expressions;
 
 public:
   ConversionExpr(const Node *Type_, NodeArray Expressions_)
       : Node(KConversionExpr), Type(Type_), Expressions(Expressions_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, Expressions); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "(";
     Type->print(S);
     S += ")(";
     Expressions.printWithComma(S);
     S += ")";
   }
 };
 
 class PointerToMemberConversionExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
   StringView Offset;
 
 public:
   PointerToMemberConversionExpr(const Node *Type_, const Node *SubExpr_,
                                 StringView Offset_)
       : Node(KPointerToMemberConversionExpr), Type(Type_), SubExpr(SubExpr_),
         Offset(Offset_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, SubExpr, Offset); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "(";
     Type->print(S);
     S += ")(";
     SubExpr->print(S);
     S += ")";
   }
 };
 
 class InitListExpr : public Node {
   const Node *Ty;
   NodeArray Inits;
 public:
   InitListExpr(const Node *Ty_, NodeArray Inits_)
       : Node(KInitListExpr), Ty(Ty_), Inits(Inits_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Inits); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (Ty)
       Ty->print(S);
     S += '{';
     Inits.printWithComma(S);
     S += '}';
   }
 };
 
 class BracedExpr : public Node {
   const Node *Elem;
   const Node *Init;
   bool IsArray;
 public:
   BracedExpr(const Node *Elem_, const Node *Init_, bool IsArray_)
       : Node(KBracedExpr), Elem(Elem_), Init(Init_), IsArray(IsArray_) {}
 
   template<typename Fn> void match(Fn F) const { F(Elem, Init, IsArray); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (IsArray) {
       S += '[';
       Elem->print(S);
       S += ']';
     } else {
       S += '.';
       Elem->print(S);
     }
     if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
       S += " = ";
     Init->print(S);
   }
 };
 
 class BracedRangeExpr : public Node {
   const Node *First;
   const Node *Last;
   const Node *Init;
 public:
   BracedRangeExpr(const Node *First_, const Node *Last_, const Node *Init_)
       : Node(KBracedRangeExpr), First(First_), Last(Last_), Init(Init_) {}
 
   template<typename Fn> void match(Fn F) const { F(First, Last, Init); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += '[';
     First->print(S);
     S += " ... ";
     Last->print(S);
     S += ']';
     if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
       S += " = ";
     Init->print(S);
FoldExpr(bool IsLeftFold_, StringView OperatorName_, const Node *Pack_,
            const Node *Init_)
       : Node(KFoldExpr), Pack(Pack_), Init(Init_), OperatorName(OperatorName_),
         IsLeftFold(IsLeftFold_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(IsLeftFold, OperatorName, Pack, Init);
   }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     auto PrintPack = [&] {
       S += '(';
       ParameterPackExpansion(Pack).print(S);
       S += ')';
     };
 
     S += '(';
 

 class ThrowExpr : public Node {
   const Node *Op;
 
 public:
   ThrowExpr(const Node *Op_) : Node(KThrowExpr), Op(Op_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "throw ";
     Op->print(S);
   }
 };
 
 class BoolExpr : public Node {
   bool Value;
 
 public:
   BoolExpr(bool Value_) : Node(KBoolExpr), Value(Value_) {}
 
   template<typename Fn> void match(Fn F) const { F(Value); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += Value ? StringView("true") : StringView("false");
   }
 };
 
 class StringLiteral : public Node {
   const Node *Type;
 
 public:
   StringLiteral(const Node *Type_) : Node(KStringLiteral), Type(Type_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "\"<";
     Type->print(S);
     S += ">\"";
   }
 };
 
 class LambdaExpr : public Node {
   const Node *Type;
 
 public:
   LambdaExpr(const Node *Type_) : Node(KLambdaExpr), Type(Type_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S += "[]";
     if (Type->getKind() == KClosureTypeName)
       static_cast<const ClosureTypeName *>(Type)->printDeclarator(S);
     S += "{...}";
   }
 };
 
 class EnumLiteral : public Node {
   // ty(integer)
   const Node *Ty;
   StringView Integer;
 
 public:
   EnumLiteral(const Node *Ty_, StringView Integer_)
       : Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Integer); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     S << "(";
     Ty->print(S);
     S << ")";
 
     if (Integer[0] == 'n')
       S << "-" << Integer.dropFront(1);
     else
       S << Integer;
   }
 };
 
 class IntegerLiteral : public Node {
   StringView Type;
   StringView Value;
 
 public:
   IntegerLiteral(StringView Type_, StringView Value_)
       : Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, Value); }
 
-  void printLeft(OutputStream &S) const override {
+  void printLeft(OutputString &S) const override {
     if (Type.size() > 3) {
       S += "(";
       S += Type;
       S += ")";
     }
 
     if (Value[0] == 'n') {
       S += "-";
static constexpr Kind KindForClass =
       float_literal_impl::getFloatLiteralKind((Float *)nullptr);
 
 public:
   FloatLiteralImpl(StringView Contents_)
       : Node(KindForClass), Contents(Contents_) {}
 
   template<typename Fn> void match(Fn F) const { F(Contents); }
 
-  void printLeft(OutputStream &s) const override {
+  void printLeft(OutputString &s) const override {
     const char *first = Contents.begin();
     const char *last = Contents.end() + 1;
 
     const size_t N = FloatData<Float>::mangled_size;
     if (static_cast<std::size_t>(last - first) > N) {
       last = first + N;
       union {
         Float value;

llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h

 #include "llvm/Demangle/DemangleConfig.h"
 #include "llvm/Demangle/StringView.h"
 #include <array>
 #include <cstdint>
 #include <string>
 
 namespace llvm {
 namespace itanium_demangle {
-class OutputStream;
+class OutputString;
 }
 }
 
-using llvm::itanium_demangle::OutputStream;
+using llvm::itanium_demangle::OutputString;
 using llvm::itanium_demangle::StringView;
 
 namespace llvm {
 namespace ms_demangle {
 
 // Storage classes
 enum Qualifiers : uint8_t {
   Q_None = 0,

 };
 
 struct Node {
   explicit Node(NodeKind K) : Kind(K) {}
   virtual ~Node() = default;
 
   NodeKind kind() const { return Kind; }
 
-  virtual void output(OutputStream &OS, OutputFlags Flags) const = 0;
+  virtual void output(OutputString &OS, OutputFlags Flags) const = 0;
 
   std::string toString(OutputFlags Flags = OF_Default) const;
 
 private:
   NodeKind Kind;
 };
 
 struct TypeNode;

 struct SymbolNode;
 struct FunctionSymbolNode;
 struct VariableSymbolNode;
 struct SpecialTableSymbolNode;
 
 struct TypeNode : public Node {
   explicit TypeNode(NodeKind K) : Node(K) {}
 
-  virtual void outputPre(OutputStream &OS, OutputFlags Flags) const = 0;
-  virtual void outputPost(OutputStream &OS, OutputFlags Flags) const = 0;
+  virtual void outputPre(OutputString &OS, OutputFlags Flags) const = 0;
+  virtual void outputPost(OutputString &OS, OutputFlags Flags) const = 0;
 
-  void output(OutputStream &OS, OutputFlags Flags) const override {
+  void output(OutputString &OS, OutputFlags Flags) const override {
     outputPre(OS, Flags);
     outputPost(OS, Flags);
   }
 
   Qualifiers Quals = Q_None;
 };
 
 struct PrimitiveTypeNode : public TypeNode {
   explicit PrimitiveTypeNode(PrimitiveKind K)
       : TypeNode(NodeKind::PrimitiveType), PrimKind(K) {}
 
-  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
-  void outputPost(OutputStream &OS, OutputFlags Flags) const override {}
+  void outputPre(OutputString &OS, OutputFlags Flags) const override;
+  void outputPost(OutputString &OS, OutputFlags Flags) const override {}
 
   PrimitiveKind PrimKind;
 };
 
 struct FunctionSignatureNode : public TypeNode {
   explicit FunctionSignatureNode(NodeKind K) : TypeNode(K) {}
   FunctionSignatureNode() : TypeNode(NodeKind::FunctionSignature) {}
 
-  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
-  void outputPost(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPre(OutputString &OS, OutputFlags Flags) const override;
+  void outputPost(OutputString &OS, OutputFlags Flags) const override;
 
   // Valid if this FunctionTypeNode is the Pointee of a PointerType or
   // MemberPointerType.
   PointerAffinity Affinity = PointerAffinity::None;
 
   // The function's calling convention.
   CallingConv CallConvention = CallingConv::None;
 

 };
 
 struct IdentifierNode : public Node {
   explicit IdentifierNode(NodeKind K) : Node(K) {}
 
   NodeArrayNode *TemplateParams = nullptr;
 
 protected:
-  void outputTemplateParameters(OutputStream &OS, OutputFlags Flags) const;
+  void outputTemplateParameters(OutputString &OS, OutputFlags Flags) const;
 };
 
 struct VcallThunkIdentifierNode : public IdentifierNode {
   VcallThunkIdentifierNode() : IdentifierNode(NodeKind::VcallThunkIdentifier) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   uint64_t OffsetInVTable = 0;
 };
 
 struct DynamicStructorIdentifierNode : public IdentifierNode {
   DynamicStructorIdentifierNode()
       : IdentifierNode(NodeKind::DynamicStructorIdentifier) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   VariableSymbolNode *Variable = nullptr;
   QualifiedNameNode *Name = nullptr;
   bool IsDestructor = false;
 };
 
 struct NamedIdentifierNode : public IdentifierNode {
   NamedIdentifierNode() : IdentifierNode(NodeKind::NamedIdentifier) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   StringView Name;
 };
 
 struct IntrinsicFunctionIdentifierNode : public IdentifierNode {
   explicit IntrinsicFunctionIdentifierNode(IntrinsicFunctionKind Operator)
       : IdentifierNode(NodeKind::IntrinsicFunctionIdentifier),
         Operator(Operator) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   IntrinsicFunctionKind Operator;
 };
 
 struct LiteralOperatorIdentifierNode : public IdentifierNode {
   LiteralOperatorIdentifierNode()
       : IdentifierNode(NodeKind::LiteralOperatorIdentifier) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   StringView Name;
 };
 
 struct LocalStaticGuardIdentifierNode : public IdentifierNode {
   LocalStaticGuardIdentifierNode()
       : IdentifierNode(NodeKind::LocalStaticGuardIdentifier) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   bool IsThread = false;
   uint32_t ScopeIndex = 0;
 };
 
 struct ConversionOperatorIdentifierNode : public IdentifierNode {
   ConversionOperatorIdentifierNode()
       : IdentifierNode(NodeKind::ConversionOperatorIdentifier) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   // The type that this operator converts too.
   TypeNode *TargetType = nullptr;
 };
 
 struct StructorIdentifierNode : public IdentifierNode {
   StructorIdentifierNode() : IdentifierNode(NodeKind::StructorIdentifier) {}
   explicit StructorIdentifierNode(bool IsDestructor)
       : IdentifierNode(NodeKind::StructorIdentifier),
         IsDestructor(IsDestructor) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   // The name of the class that this is a structor of.
   IdentifierNode *Class = nullptr;
   bool IsDestructor = false;
 };
 
 struct ThunkSignatureNode : public FunctionSignatureNode {
   ThunkSignatureNode() : FunctionSignatureNode(NodeKind::ThunkSignature) {}
 
-  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
-  void outputPost(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPre(OutputString &OS, OutputFlags Flags) const override;
+  void outputPost(OutputString &OS, OutputFlags Flags) const override;
 
   struct ThisAdjustor {
     uint32_t StaticOffset = 0;
     int32_t VBPtrOffset = 0;
     int32_t VBOffsetOffset = 0;
     int32_t VtordispOffset = 0;
   };
 
   ThisAdjustor ThisAdjust;
 };
 
 struct PointerTypeNode : public TypeNode {
   PointerTypeNode() : TypeNode(NodeKind::PointerType) {}
-  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
-  void outputPost(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPre(OutputString &OS, OutputFlags Flags) const override;
+  void outputPost(OutputString &OS, OutputFlags Flags) const override;
 
   // Is this a pointer, reference, or rvalue-reference?
   PointerAffinity Affinity = PointerAffinity::None;
 
   // If this is a member pointer, this is the class that the member is in.
   QualifiedNameNode *ClassParent = nullptr;
 
   // Represents a type X in "a pointer to X", "a reference to X", or
   // "rvalue-reference to X"
   TypeNode *Pointee = nullptr;
 };
 
 struct TagTypeNode : public TypeNode {
   explicit TagTypeNode(TagKind Tag) : TypeNode(NodeKind::TagType), Tag(Tag) {}
 
-  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
-  void outputPost(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPre(OutputString &OS, OutputFlags Flags) const override;
+  void outputPost(OutputString &OS, OutputFlags Flags) const override;
 
   QualifiedNameNode *QualifiedName = nullptr;
   TagKind Tag;
 };
 
 struct ArrayTypeNode : public TypeNode {
   ArrayTypeNode() : TypeNode(NodeKind::ArrayType) {}
 
-  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
-  void outputPost(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPre(OutputString &OS, OutputFlags Flags) const override;
+  void outputPost(OutputString &OS, OutputFlags Flags) const override;
 
-  void outputDimensionsImpl(OutputStream &OS, OutputFlags Flags) const;
-  void outputOneDimension(OutputStream &OS, OutputFlags Flags, Node *N) const;
+  void outputDimensionsImpl(OutputString &OS, OutputFlags Flags) const;
+  void outputOneDimension(OutputString &OS, OutputFlags Flags, Node *N) const;
 
   // A list of array dimensions.  e.g. [3,4,5] in `int Foo[3][4][5]`
   NodeArrayNode *Dimensions = nullptr;
 
   // The type of array element.
   TypeNode *ElementType = nullptr;
 };
 
 struct IntrinsicNode : public TypeNode {
   IntrinsicNode() : TypeNode(NodeKind::IntrinsicType) {}
-  void output(OutputStream &OS, OutputFlags Flags) const override {}
+  void output(OutputString &OS, OutputFlags Flags) const override {}
 };
 
 struct CustomTypeNode : public TypeNode {
   CustomTypeNode() : TypeNode(NodeKind::Custom) {}
 
-  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
-  void outputPost(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPre(OutputString &OS, OutputFlags Flags) const override;
+  void outputPost(OutputString &OS, OutputFlags Flags) const override;
 
   IdentifierNode *Identifier = nullptr;
 };
 
 struct NodeArrayNode : public Node {
   NodeArrayNode() : Node(NodeKind::NodeArray) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
-  void output(OutputStream &OS, OutputFlags Flags, StringView Separator) const;
+  void output(OutputString &OS, OutputFlags Flags, StringView Separator) const;
 
   Node **Nodes = nullptr;
   size_t Count = 0;
 };
 
 struct QualifiedNameNode : public Node {
   QualifiedNameNode() : Node(NodeKind::QualifiedName) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   NodeArrayNode *Components = nullptr;
 
   IdentifierNode *getUnqualifiedIdentifier() {
     Node *LastComponent = Components->Nodes[Components->Count - 1];
     return static_cast<IdentifierNode *>(LastComponent);
   }
 };
 
 struct TemplateParameterReferenceNode : public Node {
   TemplateParameterReferenceNode()
       : Node(NodeKind::TemplateParameterReference) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   SymbolNode *Symbol = nullptr;
 
   int ThunkOffsetCount = 0;
   std::array<int64_t, 3> ThunkOffsets;
   PointerAffinity Affinity = PointerAffinity::None;
   bool IsMemberPointer = false;
 };
 
 struct IntegerLiteralNode : public Node {
   IntegerLiteralNode() : Node(NodeKind::IntegerLiteral) {}
   IntegerLiteralNode(uint64_t Value, bool IsNegative)
       : Node(NodeKind::IntegerLiteral), Value(Value), IsNegative(IsNegative) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   uint64_t Value = 0;
   bool IsNegative = false;
 };
 
 struct RttiBaseClassDescriptorNode : public IdentifierNode {
   RttiBaseClassDescriptorNode()
       : IdentifierNode(NodeKind::RttiBaseClassDescriptor) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   uint32_t NVOffset = 0;
   int32_t VBPtrOffset = 0;
   uint32_t VBTableOffset = 0;
   uint32_t Flags = 0;
 };
 
 struct SymbolNode : public Node {
   explicit SymbolNode(NodeKind K) : Node(K) {}
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
   QualifiedNameNode *Name = nullptr;
 };
 
 struct SpecialTableSymbolNode : public SymbolNode {
   explicit SpecialTableSymbolNode()
       : SymbolNode(NodeKind::SpecialTableSymbol) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
   QualifiedNameNode *TargetName = nullptr;
   Qualifiers Quals = Qualifiers::Q_None;
 };
 
 struct LocalStaticGuardVariableNode : public SymbolNode {
   LocalStaticGuardVariableNode()
       : SymbolNode(NodeKind::LocalStaticGuardVariable) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   bool IsVisible = false;
 };
 
 struct EncodedStringLiteralNode : public SymbolNode {
   EncodedStringLiteralNode() : SymbolNode(NodeKind::EncodedStringLiteral) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   StringView DecodedString;
   bool IsTruncated = false;
   CharKind Char = CharKind::Char;
 };
 
 struct VariableSymbolNode : public SymbolNode {
   VariableSymbolNode() : SymbolNode(NodeKind::VariableSymbol) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   StorageClass SC = StorageClass::None;
   TypeNode *Type = nullptr;
 };
 
 struct FunctionSymbolNode : public SymbolNode {
   FunctionSymbolNode() : SymbolNode(NodeKind::FunctionSymbol) {}
 
-  void output(OutputStream &OS, OutputFlags Flags) const override;
+  void output(OutputString &OS, OutputFlags Flags) const override;
 
   FunctionSignatureNode *Signature = nullptr;
 };
 
 } // namespace ms_demangle
 } // namespace llvm
 
 #endif

llvm/include/llvm/Demangle/Utility.h

 //===--- Utility.h ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Provide some utility classes for use in the demangler(s).
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_DEMANGLE_UTILITY_H
-#define LLVM_DEMANGLE_UTILITY_H
+#ifndef DEMANGLE_UTILITY_H
+#define DEMANGLE_UTILITY_H
 
 #include "StringView.h"
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <iterator>
 #include <limits>
 
 DEMANGLE_NAMESPACE_BEGIN
 
 // Stream that AST nodes write their string representation into after the AST
 // has been parsed.
-class OutputStream {
+class OutputString {
   char *Buffer = nullptr;
   size_t CurrentPosition = 0;
   size_t BufferCapacity = 0;
 
   // Ensure there is at least n more positions in buffer.
   void grow(size_t N) {
     if (N + CurrentPosition >= BufferCapacity) {
       BufferCapacity *= 2;
void writeUnsigned(uint64_t N, bool isNeg = false) {
 
     // Add negative sign...
     if (isNeg)
       *--TempPtr = '-';
     this->operator<<(StringView(TempPtr, std::end(Temp)));
   }
 
 public:
-  OutputStream(char *StartBuf, size_t Size)
+  OutputString(char *StartBuf, size_t Size)
       : Buffer(StartBuf), CurrentPosition(0), BufferCapacity(Size) {}
-  OutputStream() = default;
+  OutputString() = default;
   void reset(char *Buffer_, size_t BufferCapacity_) {
     CurrentPosition = 0;
     Buffer = Buffer_;
     BufferCapacity = BufferCapacity_;
   }
 
   /// If a ParameterPackExpansion (or similar type) is encountered, the offset
   /// into the pack that we're currently printing.
   unsigned CurrentPackIndex = std::numeric_limits<unsigned>::max();
   unsigned CurrentPackMax = std::numeric_limits<unsigned>::max();
 
-  OutputStream &operator+=(StringView R) {
+  OutputString &operator+=(StringView R) {
     size_t Size = R.size();
     if (Size == 0)
       return *this;
     grow(Size);
     std::memmove(Buffer + CurrentPosition, R.begin(), Size);
     CurrentPosition += Size;
     return *this;
   }
 
-  OutputStream &operator+=(char C) {
+  OutputString &operator+=(char C) {
     grow(1);
     Buffer[CurrentPosition++] = C;
     return *this;
   }
 
-  OutputStream &operator<<(StringView R) { return (*this += R); }
+  OutputString &operator<<(StringView R) { return (*this += R); }
 
-  OutputStream &operator<<(char C) { return (*this += C); }
+  OutputString &operator<<(char C) { return (*this += C); }
 
-  OutputStream &operator<<(long long N) {
+  OutputString &operator<<(long long N) {
     if (N < 0)
       writeUnsigned(static_cast<unsigned long long>(-N), true);
     else
       writeUnsigned(static_cast<unsigned long long>(N));
     return *this;
   }
 
-  OutputStream &operator<<(unsigned long long N) {
+  OutputString &operator<<(unsigned long long N) {
     writeUnsigned(N, false);
     return *this;
   }
 
-  OutputStream &operator<<(long N) {
+  OutputString &operator<<(long N) {
     return this->operator<<(static_cast<long long>(N));
   }
 
-  OutputStream &operator<<(unsigned long N) {
+  OutputString &operator<<(unsigned long N) {
     return this->operator<<(static_cast<unsigned long long>(N));
   }
 
-  OutputStream &operator<<(int N) {
+  OutputString &operator<<(int N) {
     return this->operator<<(static_cast<long long>(N));
   }
 
-  OutputStream &operator<<(unsigned int N) {
+  OutputString &operator<<(unsigned int N) {
     return this->operator<<(static_cast<unsigned long long>(N));
   }
 
   void insert(size_t Pos, const char *S, size_t N) {
     assert(Pos <= CurrentPosition);
     if (N == 0)
       return;
     grow(N);
void restoreNow(bool Force) {
     Restore = std::move(OriginalValue);
     ShouldRestore = false;
   }
 
   SwapAndRestore(const SwapAndRestore &) = delete;
   SwapAndRestore &operator=(const SwapAndRestore &) = delete;
 };
 
-inline bool initializeOutputStream(char *Buf, size_t *N, OutputStream &S,
+inline bool initializeOutputString(char *Buf, size_t *N, OutputString &S,
                                    size_t InitSize) {
   size_t BufferSize;
   if (Buf == nullptr) {
     Buf = static_cast<char *>(std::malloc(InitSize));
     if (Buf == nullptr)
       return false;
     BufferSize = InitSize;
   } else

llvm/lib/Demangle/ItaniumDemangle.cpp

char *llvm::itaniumDemangle(const char *MangledName, char *Buf,
   if (MangledName == nullptr || (Buf != nullptr && N == nullptr)) {
     if (Status)
       *Status = demangle_invalid_args;
     return nullptr;
   }
 
   int InternalStatus = demangle_success;
   Demangler Parser(MangledName, MangledName + std::strlen(MangledName));
-  OutputStream S;
+  OutputString S;
 
   Node *AST = Parser.parse();
 
   if (AST == nullptr)
     InternalStatus = demangle_invalid_mangled_name;
-  else if (!initializeOutputStream(Buf, N, S, 1024))
+  else if (!initializeOutputString(Buf, N, S, 1024))
     InternalStatus = demangle_memory_alloc_failure;
   else {
     assert(Parser.ForwardTemplateRefs.empty());
     AST->print(S);
     S += '\0';
     if (N != nullptr)
       *N = S.getCurrentPosition();
     Buf = S.getBuffer();
bool ItaniumPartialDemangler::partialDemangle(const char *MangledName) {
   Demangler *Parser = static_cast<Demangler *>(Context);
   size_t Len = std::strlen(MangledName);
   Parser->reset(MangledName, MangledName + Len);
   RootNode = Parser->parse();
   return RootNode == nullptr;
 }
 
 static char *printNode(const Node *RootNode, char *Buf, size_t *N) {
-  OutputStream S;
-  if (!initializeOutputStream(Buf, N, S, 128))
+  OutputString S;
+  if (!initializeOutputString(Buf, N, S, 128))
     return nullptr;
   RootNode->print(S);
   S += '\0';
   if (N != nullptr)
     *N = S.getCurrentPosition();
   return S.getBuffer();
 }
 

 }
 
 char *ItaniumPartialDemangler::getFunctionDeclContextName(char *Buf,
                                                           size_t *N) const {
   if (!isFunction())
     return nullptr;
   const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName();
 
-  OutputStream S;
-  if (!initializeOutputStream(Buf, N, S, 128))
+  OutputString S;
+  if (!initializeOutputString(Buf, N, S, 128))
     return nullptr;
 
  KeepGoingLocalFunction:
   while (true) {
     if (Name->getKind() == Node::KAbiTagAttr) {
       Name = static_cast<const AbiTagAttr *>(Name)->Base;
       continue;
     }

 }
 
 char *ItaniumPartialDemangler::getFunctionParameters(char *Buf,
                                                      size_t *N) const {
   if (!isFunction())
     return nullptr;
   NodeArray Params = static_cast<FunctionEncoding *>(RootNode)->getParams();
 
-  OutputStream S;
-  if (!initializeOutputStream(Buf, N, S, 128))
+  OutputString S;
+  if (!initializeOutputString(Buf, N, S, 128))
     return nullptr;
 
   S += '(';
   Params.printWithComma(S);
   S += ')';
   S += '\0';
   if (N != nullptr)
     *N = S.getCurrentPosition();
   return S.getBuffer();
 }
 
 char *ItaniumPartialDemangler::getFunctionReturnType(
     char *Buf, size_t *N) const {
   if (!isFunction())
     return nullptr;
 
-  OutputStream S;
-  if (!initializeOutputStream(Buf, N, S, 128))
+  OutputString S;
+  if (!initializeOutputString(Buf, N, S, 128))
     return nullptr;
 
   if (const Node *Ret =
           static_cast<const FunctionEncoding *>(RootNode)->getReturnType())
     Ret->print(S);
 
   S += '\0';
   if (N != nullptr)

llvm/lib/Demangle/MicrosoftDemangle.cpp

NamedIdentifierNode *Demangler::demangleBackRefName(StringView &MangledName) {
 
   MangledName = MangledName.dropFront();
   return Backrefs.Names[I];
 }
 
 void Demangler::memorizeIdentifier(IdentifierNode *Identifier) {
   // Render this class template name into a string buffer so that we can
   // memorize it for the purpose of back-referencing.
-  OutputStream OS;
-  if (!initializeOutputStream(nullptr, nullptr, OS, 1024))
+  OutputString OS;
+  if (!initializeOutputString(nullptr, nullptr, OS, 1024))
     // FIXME: Propagate out-of-memory as an error?
     std::terminate();
   Identifier->output(OS, OF_Default);
   OS << '\0';
   char *Name = OS.getBuffer();
 
   StringView Owned = copyString(Name);
   memorizeString(Owned);
WCharLiteralError:
   return L'\0';
 }
 
 static void writeHexDigit(char *Buffer, uint8_t Digit) {
   assert(Digit <= 15);
   *Buffer = (Digit < 10) ? ('0' + Digit) : ('A' + Digit - 10);
 }
 
-static void outputHex(OutputStream &OS, unsigned C) {
+static void outputHex(OutputString &OS, unsigned C) {
   assert (C != 0);
 
   // It's easier to do the math if we can work from right to left, but we need
   // to print the numbers from left to right.  So render this into a temporary
   // buffer first, then output the temporary buffer.  Each byte is of the form
   // \xAB, which means that each byte needs 4 characters.  Since there are at
   // most 4 bytes, we need a 4*4+1 = 17 character temporary buffer.
   char TempBuffer[17];
while (C != 0) {
     }
   }
   TempBuffer[Pos--] = 'x';
   assert(Pos >= 0);
   TempBuffer[Pos--] = '\\';
   OS << StringView(&TempBuffer[Pos + 1]);
 }
 
-static void outputEscapedChar(OutputStream &OS, unsigned C) {
+static void outputEscapedChar(OutputString &OS, unsigned C) {
   switch (C) {
   case '\0': // nul
     OS << "\\0";
     return;
   case '\'': // single quote
     OS << "\\\'";
     return;
   case '\"': // double quote
FunctionSymbolNode *Demangler::demangleVcallThunkNode(StringView &MangledName) {
   if (!Error)
     FSN->Signature->CallConvention = demangleCallingConvention(MangledName);
   return (Error) ? nullptr : FSN;
 }
 
 EncodedStringLiteralNode *
 Demangler::demangleStringLiteral(StringView &MangledName) {
   // This function uses goto, so declare all variables up front.
-  OutputStream OS;
+  OutputString OS;
   StringView CRC;
   uint64_t StringByteSize;
   bool IsWcharT = false;
   bool IsNegative = false;
   size_t CrcEndPos = 0;
   char *ResultBuffer = nullptr;
 
   EncodedStringLiteralNode *Result = Arena.alloc<EncodedStringLiteralNode>();
 
   // Must happen before the first `goto StringLiteralError`.
-  if (!initializeOutputStream(nullptr, nullptr, OS, 1024))
+  if (!initializeOutputString(nullptr, nullptr, OS, 1024))
     // FIXME: Propagate out-of-memory as an error?
     std::terminate();
 
   // Prefix indicating the beginning of a string literal
   if (!MangledName.consumeFront("@_"))
     goto StringLiteralError;
   if (MangledName.empty())
     goto StringLiteralError;
Demangler::demangleLocallyScopedNamePiece(StringView &MangledName) {
   MangledName.consumeFront('?');
 
   assert(!Error);
   Node *Scope = parse(MangledName);
   if (Error)
     return nullptr;
 
   // Render the parent symbol's name into a buffer.
-  OutputStream OS;
-  if (!initializeOutputStream(nullptr, nullptr, OS, 1024))
+  OutputString OS;
+  if (!initializeOutputString(nullptr, nullptr, OS, 1024))
     // FIXME: Propagate out-of-memory as an error?
     std::terminate();
   OS << '`';
   Scope->output(OS, OF_Default);
   OS << '\'';
   OS << "::`" << Number << "'";
   OS << '\0';
   char *Result = OS.getBuffer();
Demangler::demangleTemplateParameterList(StringView &MangledName) {
   return nodeListToNodeArray(Arena, Head, Count);
 }
 
 void Demangler::dumpBackReferences() {
   std::printf("%d function parameter backreferences\n",
               (int)Backrefs.FunctionParamCount);
 
   // Create an output stream so we can render each type.
-  OutputStream OS;
-  if (!initializeOutputStream(nullptr, nullptr, OS, 1024))
+  OutputString OS;
+  if (!initializeOutputString(nullptr, nullptr, OS, 1024))
     std::terminate();
   for (size_t I = 0; I < Backrefs.FunctionParamCount; ++I) {
     OS.setCurrentPosition(0);
 
     TypeNode *T = Backrefs.FunctionParams[I];
     T->output(OS, OF_Default);
 
     std::printf("  [%d] - %.*s\n", (int)I, (int)OS.getCurrentPosition(),
void Demangler::dumpBackReferences() {
   if (Backrefs.NamesCount > 0)
     std::printf("\n");
 }
 
 char *llvm::microsoftDemangle(const char *MangledName, size_t *NMangled,
                               char *Buf, size_t *N,
                               int *Status, MSDemangleFlags Flags) {
   Demangler D;
-  OutputStream S;
+  OutputString S;
 
   StringView Name{MangledName};
   SymbolNode *AST = D.parse(Name);
   if (!D.Error && NMangled)
     *NMangled = Name.begin() - MangledName;
 
   if (Flags & MSDF_DumpBackrefs)
     D.dumpBackReferences();
 
   OutputFlags OF = OF_Default;
   if (Flags & MSDF_NoCallingConvention)
     OF = OutputFlags(OF | OF_NoCallingConvention);
   if (Flags & MSDF_NoAccessSpecifier)
     OF = OutputFlags(OF | OF_NoAccessSpecifier);
   if (Flags & MSDF_NoReturnType)
     OF = OutputFlags(OF | OF_NoReturnType);
   if (Flags & MSDF_NoMemberType)
     OF = OutputFlags(OF | OF_NoMemberType);
 
   int InternalStatus = demangle_success;
   if (D.Error)
     InternalStatus = demangle_invalid_mangled_name;
-  else if (!initializeOutputStream(Buf, N, S, 1024))
+  else if (!initializeOutputString(Buf, N, S, 1024))
     InternalStatus = demangle_memory_alloc_failure;
   else {
     AST->output(S, OF);
     S += '\0';
     if (N != nullptr)
       *N = S.getCurrentPosition();
     Buf = S.getBuffer();
   }
 
   if (Status)
     *Status = InternalStatus;
   return InternalStatus == demangle_success ? Buf : nullptr;
 }

llvm/lib/Demangle/MicrosoftDemangleNodes.cpp

 using namespace ms_demangle;
 
 #define OUTPUT_ENUM_CLASS_VALUE(Enum, Value, Desc)                             \
   case Enum::Value:                                                            \
     OS << Desc;                                                                \
     break;
 
 // Writes a space if the last token does not end with a punctuation.
-static void outputSpaceIfNecessary(OutputStream &OS) {
+static void outputSpaceIfNecessary(OutputString &OS) {
   if (OS.empty())
     return;
 
   char C = OS.back();
   if (std::isalnum(C) || C == '>')
     OS << " ";
 }
 
-static void outputSingleQualifier(OutputStream &OS, Qualifiers Q) {
+static void outputSingleQualifier(OutputString &OS, Qualifiers Q) {
   switch (Q) {
   case Q_Const:
     OS << "const";
     break;
   case Q_Volatile:
     OS << "volatile";
     break;
   case Q_Restrict:
     OS << "__restrict";
     break;
   default:
     break;
   }
 }
 
-static bool outputQualifierIfPresent(OutputStream &OS, Qualifiers Q,
+static bool outputQualifierIfPresent(OutputString &OS, Qualifiers Q,
                                      Qualifiers Mask, bool NeedSpace) {
   if (!(Q & Mask))
     return NeedSpace;
 
   if (NeedSpace)
     OS << " ";
 
   outputSingleQualifier(OS, Mask);
   return true;
 }
 
-static void outputQualifiers(OutputStream &OS, Qualifiers Q, bool SpaceBefore,
+static void outputQualifiers(OutputString &OS, Qualifiers Q, bool SpaceBefore,
                              bool SpaceAfter) {
   if (Q == Q_None)
     return;
 
   size_t Pos1 = OS.getCurrentPosition();
   SpaceBefore = outputQualifierIfPresent(OS, Q, Q_Const, SpaceBefore);
   SpaceBefore = outputQualifierIfPresent(OS, Q, Q_Volatile, SpaceBefore);
   SpaceBefore = outputQualifierIfPresent(OS, Q, Q_Restrict, SpaceBefore);
   size_t Pos2 = OS.getCurrentPosition();
   if (SpaceAfter && Pos2 > Pos1)
     OS << " ";
 }
 
-static void outputCallingConvention(OutputStream &OS, CallingConv CC) {
+static void outputCallingConvention(OutputString &OS, CallingConv CC) {
   outputSpaceIfNecessary(OS);
 
   switch (CC) {
   case CallingConv::Cdecl:
     OS << "__cdecl";
     break;
   case CallingConv::Fastcall:
     OS << "__fastcall";
case CallingConv::SwiftAsync:
     OS << "__attribute__((__swiftasynccall__)) ";
     break;
   default:
     break;
   }
 }
 
 std::string Node::toString(OutputFlags Flags) const {
-  OutputStream OS;
-  initializeOutputStream(nullptr, nullptr, OS, 1024);
+  OutputString OS;
+  initializeOutputString(nullptr, nullptr, OS, 1024);
   this->output(OS, Flags);
   OS << '\0';
   std::string Owned(OS.getBuffer());
   std::free(OS.getBuffer());
   return Owned;
 }
 
-void PrimitiveTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
+void PrimitiveTypeNode::outputPre(OutputString &OS, OutputFlags Flags) const {
   switch (PrimKind) {
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Void, "void");
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Bool, "bool");
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char, "char");
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Schar, "signed char");
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uchar, "unsigned char");
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char8, "char8_t");
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char16, "char16_t");
switch (PrimKind) {
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Float, "float");
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Double, "double");
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ldouble, "long double");
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Nullptr, "std::nullptr_t");
   }
   outputQualifiers(OS, Quals, true, false);
 }
 
-void NodeArrayNode::output(OutputStream &OS, OutputFlags Flags) const {
+void NodeArrayNode::output(OutputString &OS, OutputFlags Flags) const {
   output(OS, Flags, ", ");
 }
 
-void NodeArrayNode::output(OutputStream &OS, OutputFlags Flags,
+void NodeArrayNode::output(OutputString &OS, OutputFlags Flags,
                            StringView Separator) const {
   if (Count == 0)
     return;
   if (Nodes[0])
     Nodes[0]->output(OS, Flags);
   for (size_t I = 1; I < Count; ++I) {
     OS << Separator;
     Nodes[I]->output(OS, Flags);
   }
 }
 
-void EncodedStringLiteralNode::output(OutputStream &OS,
+void EncodedStringLiteralNode::output(OutputString &OS,
                                       OutputFlags Flags) const {
   switch (Char) {
   case CharKind::Wchar:
     OS << "L\"";
     break;
   case CharKind::Char:
     OS << "\"";
     break;
   case CharKind::Char16:
     OS << "u\"";
     break;
   case CharKind::Char32:
     OS << "U\"";
     break;
   }
   OS << DecodedString << "\"";
   if (IsTruncated)
     OS << "...";
 }
 
-void IntegerLiteralNode::output(OutputStream &OS, OutputFlags Flags) const {
+void IntegerLiteralNode::output(OutputString &OS, OutputFlags Flags) const {
   if (IsNegative)
     OS << '-';
   OS << Value;
 }
 
-void TemplateParameterReferenceNode::output(OutputStream &OS,
+void TemplateParameterReferenceNode::output(OutputString &OS,
                                             OutputFlags Flags) const {
   if (ThunkOffsetCount > 0)
     OS << "{";
   else if (Affinity == PointerAffinity::Pointer)
     OS << "&";
 
   if (Symbol) {
     Symbol->output(OS, Flags);
     if (ThunkOffsetCount > 0)
       OS << ", ";
   }
 
   if (ThunkOffsetCount > 0)
     OS << ThunkOffsets[0];
   for (int I = 1; I < ThunkOffsetCount; ++I) {
     OS << ", " << ThunkOffsets[I];
   }
   if (ThunkOffsetCount > 0)
     OS << "}";
 }
 
-void IdentifierNode::outputTemplateParameters(OutputStream &OS,
+void IdentifierNode::outputTemplateParameters(OutputString &OS,
                                               OutputFlags Flags) const {
   if (!TemplateParams)
     return;
   OS << "<";
   TemplateParams->output(OS, Flags);
   OS << ">";
 }
 
-void DynamicStructorIdentifierNode::output(OutputStream &OS,
+void DynamicStructorIdentifierNode::output(OutputString &OS,
                                            OutputFlags Flags) const {
   if (IsDestructor)
     OS << "`dynamic atexit destructor for ";
   else
     OS << "`dynamic initializer for ";
 
   if (Variable) {
     OS << "`";
     Variable->output(OS, Flags);
     OS << "''";
   } else {
     OS << "'";
     Name->output(OS, Flags);
     OS << "''";
   }
 }
 
-void NamedIdentifierNode::output(OutputStream &OS, OutputFlags Flags) const {
+void NamedIdentifierNode::output(OutputString &OS, OutputFlags Flags) const {
   OS << Name;
   outputTemplateParameters(OS, Flags);
 }
 
-void IntrinsicFunctionIdentifierNode::output(OutputStream &OS,
+void IntrinsicFunctionIdentifierNode::output(OutputString &OS,
                                              OutputFlags Flags) const {
   switch (Operator) {
     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, New, "operator new");
     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Delete, "operator delete");
     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Assign, "operator=");
     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RightShift, "operator>>");
     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LeftShift, "operator<<");
     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalNot, "operator!");
switch (Operator) {
     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Spaceship, "operator<=>");
   case IntrinsicFunctionKind::MaxIntrinsic:
   case IntrinsicFunctionKind::None:
     break;
   }
   outputTemplateParameters(OS, Flags);
 }
 
-void LocalStaticGuardIdentifierNode::output(OutputStream &OS,
+void LocalStaticGuardIdentifierNode::output(OutputString &OS,
                                             OutputFlags Flags) const {
   if (IsThread)
     OS << "`local static thread guard'";
   else
     OS << "`local static guard'";
   if (ScopeIndex > 0)
     OS << "{" << ScopeIndex << "}";
 }
 
-void ConversionOperatorIdentifierNode::output(OutputStream &OS,
+void ConversionOperatorIdentifierNode::output(OutputString &OS,
                                               OutputFlags Flags) const {
   OS << "operator";
   outputTemplateParameters(OS, Flags);
   OS << " ";
   TargetType->output(OS, Flags);
 }
 
-void StructorIdentifierNode::output(OutputStream &OS, OutputFlags Flags) const {
+void StructorIdentifierNode::output(OutputString &OS, OutputFlags Flags) const {
   if (IsDestructor)
     OS << "~";
   Class->output(OS, Flags);
   outputTemplateParameters(OS, Flags);
 }
 
-void LiteralOperatorIdentifierNode::output(OutputStream &OS,
+void LiteralOperatorIdentifierNode::output(OutputString &OS,
                                            OutputFlags Flags) const {
   OS << "operator \"\"" << Name;
   outputTemplateParameters(OS, Flags);
 }
 
-void FunctionSignatureNode::outputPre(OutputStream &OS,
+void FunctionSignatureNode::outputPre(OutputString &OS,
                                       OutputFlags Flags) const {
   if (!(Flags & OF_NoAccessSpecifier)) {
     if (FunctionClass & FC_Public)
       OS << "public: ";
     if (FunctionClass & FC_Protected)
       OS << "protected: ";
     if (FunctionClass & FC_Private)
       OS << "private: ";
if (!(Flags & OF_NoReturnType) && ReturnType) {
     ReturnType->outputPre(OS, Flags);
     OS << " ";
   }
 
   if (!(Flags & OF_NoCallingConvention))
     outputCallingConvention(OS, CallConvention);
 }
 
-void FunctionSignatureNode::outputPost(OutputStream &OS,
+void FunctionSignatureNode::outputPost(OutputString &OS,
                                        OutputFlags Flags) const {
   if (!(FunctionClass & FC_NoParameterList)) {
     OS << "(";
     if (Params)
       Params->output(OS, Flags);
     else
       OS << "void";
 
if (RefQualifier == FunctionRefQualifier::Reference)
     OS << " &";
   else if (RefQualifier == FunctionRefQualifier::RValueReference)
     OS << " &&";
 
   if (!(Flags & OF_NoReturnType) && ReturnType)
     ReturnType->outputPost(OS, Flags);
 }
 
-void ThunkSignatureNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
+void ThunkSignatureNode::outputPre(OutputString &OS, OutputFlags Flags) const {
   OS << "[thunk]: ";
 
   FunctionSignatureNode::outputPre(OS, Flags);
 }
 
-void ThunkSignatureNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
+void ThunkSignatureNode::outputPost(OutputString &OS, OutputFlags Flags) const {
   if (FunctionClass & FC_StaticThisAdjust) {
     OS << "`adjustor{" << ThisAdjust.StaticOffset << "}'";
   } else if (FunctionClass & FC_VirtualThisAdjust) {
     if (FunctionClass & FC_VirtualThisAdjustEx) {
       OS << "`vtordispex{" << ThisAdjust.VBPtrOffset << ", "
          << ThisAdjust.VBOffsetOffset << ", " << ThisAdjust.VtordispOffset
          << ", " << ThisAdjust.StaticOffset << "}'";
     } else {
       OS << "`vtordisp{" << ThisAdjust.VtordispOffset << ", "
          << ThisAdjust.StaticOffset << "}'";
     }
   }
 
   FunctionSignatureNode::outputPost(OS, Flags);
 }
 
-void PointerTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
+void PointerTypeNode::outputPre(OutputString &OS, OutputFlags Flags) const {
   if (Pointee->kind() == NodeKind::FunctionSignature) {
     // If this is a pointer to a function, don't output the calling convention.
     // It needs to go inside the parentheses.
     const FunctionSignatureNode *Sig =
         static_cast<const FunctionSignatureNode *>(Pointee);
     Sig->outputPre(OS, OF_NoCallingConvention);
   } else
     Pointee->outputPre(OS, Flags);
case PointerAffinity::RValueReference:
     OS << "&&";
     break;
   default:
     assert(false);
   }
   outputQualifiers(OS, Quals, false, false);
 }
 
-void PointerTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
+void PointerTypeNode::outputPost(OutputString &OS, OutputFlags Flags) const {
   if (Pointee->kind() == NodeKind::ArrayType ||
       Pointee->kind() == NodeKind::FunctionSignature)
     OS << ")";
 
   Pointee->outputPost(OS, Flags);
 }
 
-void TagTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
+void TagTypeNode::outputPre(OutputString &OS, OutputFlags Flags) const {
   if (!(Flags & OF_NoTagSpecifier)) {
     switch (Tag) {
       OUTPUT_ENUM_CLASS_VALUE(TagKind, Class, "class");
       OUTPUT_ENUM_CLASS_VALUE(TagKind, Struct, "struct");
       OUTPUT_ENUM_CLASS_VALUE(TagKind, Union, "union");
       OUTPUT_ENUM_CLASS_VALUE(TagKind, Enum, "enum");
     }
     OS << " ";
   }
   QualifiedName->output(OS, Flags);
   outputQualifiers(OS, Quals, true, false);
 }
 
-void TagTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {}
+void TagTypeNode::outputPost(OutputString &OS, OutputFlags Flags) const {}
 
-void ArrayTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
+void ArrayTypeNode::outputPre(OutputString &OS, OutputFlags Flags) const {
   ElementType->outputPre(OS, Flags);
   outputQualifiers(OS, Quals, true, false);
 }
 
-void ArrayTypeNode::outputOneDimension(OutputStream &OS, OutputFlags Flags,
+void ArrayTypeNode::outputOneDimension(OutputString &OS, OutputFlags Flags,
                                        Node *N) const {
   assert(N->kind() == NodeKind::IntegerLiteral);
   IntegerLiteralNode *ILN = static_cast<IntegerLiteralNode *>(N);
   if (ILN->Value != 0)
     ILN->output(OS, Flags);
 }
 
-void ArrayTypeNode::outputDimensionsImpl(OutputStream &OS,
+void ArrayTypeNode::outputDimensionsImpl(OutputString &OS,
                                          OutputFlags Flags) const {
   if (Dimensions->Count == 0)
     return;
 
   outputOneDimension(OS, Flags, Dimensions->Nodes[0]);
   for (size_t I = 1; I < Dimensions->Count; ++I) {
     OS << "][";
     outputOneDimension(OS, Flags, Dimensions->Nodes[I]);
   }
 }
 
-void ArrayTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
+void ArrayTypeNode::outputPost(OutputString &OS, OutputFlags Flags) const {
   OS << "[";
   outputDimensionsImpl(OS, Flags);
   OS << "]";
 
   ElementType->outputPost(OS, Flags);
 }
 
-void SymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
+void SymbolNode::output(OutputString &OS, OutputFlags Flags) const {
   Name->output(OS, Flags);
 }
 
-void FunctionSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
+void FunctionSymbolNode::output(OutputString &OS, OutputFlags Flags) const {
   Signature->outputPre(OS, Flags);
   outputSpaceIfNecessary(OS);
   Name->output(OS, Flags);
   Signature->outputPost(OS, Flags);
 }
 
-void VariableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
+void VariableSymbolNode::output(OutputString &OS, OutputFlags Flags) const {
   const char *AccessSpec = nullptr;
   bool IsStatic = true;
   switch (SC) {
   case StorageClass::PrivateStatic:
     AccessSpec = "private";
     break;
   case StorageClass::PublicStatic:
     AccessSpec = "public";
if (Type) {
     Type->outputPre(OS, Flags);
     outputSpaceIfNecessary(OS);
   }
   Name->output(OS, Flags);
   if (Type)
     Type->outputPost(OS, Flags);
 }
 
-void CustomTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
+void CustomTypeNode::outputPre(OutputString &OS, OutputFlags Flags) const {
   Identifier->output(OS, Flags);
 }
-void CustomTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {}
+void CustomTypeNode::outputPost(OutputString &OS, OutputFlags Flags) const {}
 
-void QualifiedNameNode::output(OutputStream &OS, OutputFlags Flags) const {
+void QualifiedNameNode::output(OutputString &OS, OutputFlags Flags) const {
   Components->output(OS, Flags, "::");
 }
 
-void RttiBaseClassDescriptorNode::output(OutputStream &OS,
+void RttiBaseClassDescriptorNode::output(OutputString &OS,
                                          OutputFlags Flags) const {
   OS << "`RTTI Base Class Descriptor at (";
   OS << NVOffset << ", " << VBPtrOffset << ", " << VBTableOffset << ", "
      << this->Flags;
   OS << ")'";
 }
 
-void LocalStaticGuardVariableNode::output(OutputStream &OS,
+void LocalStaticGuardVariableNode::output(OutputString &OS,
                                           OutputFlags Flags) const {
   Name->output(OS, Flags);
 }
 
-void VcallThunkIdentifierNode::output(OutputStream &OS,
+void VcallThunkIdentifierNode::output(OutputString &OS,
                                       OutputFlags Flags) const {
   OS << "`vcall'{" << OffsetInVTable << ", {flat}}";
 }
 
-void SpecialTableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
+void SpecialTableSymbolNode::output(OutputString &OS, OutputFlags Flags) const {
   outputQualifiers(OS, Quals, false, true);
   Name->output(OS, Flags);
   if (TargetName) {
     OS << "{for `";
     TargetName->output(OS, Flags);
     OS << "'}";
   }
 }

llvm/lib/Demangle/RustDemangle.cpp

 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstring>
 #include <limits>
 
 using namespace llvm;
 
-using llvm::itanium_demangle::OutputStream;
+using llvm::itanium_demangle::OutputString;
 using llvm::itanium_demangle::StringView;
 using llvm::itanium_demangle::SwapAndRestore;
 
 namespace {
 
 struct Identifier {
   StringView Name;
   bool Punycode;
class Demangler {
   // When true, print methods append the output to the stream.
   // When false, the output is suppressed.
   bool Print;
   // True if an error occurred.
   bool Error;
 
 public:
   // Demangled output.
-  OutputStream Output;
+  OutputString Output;
 
   Demangler(size_t MaxRecursionLevel = 500);
 
   bool demangle(StringView MangledName);
 
 private:
   bool demanglePath(IsInType Type,
                     LeaveGenericsOpen LeaveOpen = LeaveGenericsOpen::No);
char *llvm::rustDemangle(const char *MangledName, char *Buf, size_t *N,
   StringView Mangled(MangledName);
   if (!Mangled.startsWith("_R")) {
     if (Status != nullptr)
       *Status = demangle_invalid_mangled_name;
     return nullptr;
   }
 
   Demangler D;
-  if (!initializeOutputStream(nullptr, nullptr, D.Output, 1024)) {
+  if (!initializeOutputString(nullptr, nullptr, D.Output, 1024)) {
     if (Status != nullptr)
       *Status = demangle_memory_alloc_failure;
     return nullptr;
   }
 
   if (!D.demangle(Mangled)) {
     if (Status != nullptr)
       *Status = demangle_invalid_mangled_name;
static inline bool decodePunycodeDigit(char C, size_t &Value) {
   if (isDigit(C)) {
     Value = 26 + (C - '0');
     return true;
   }
 
   return false;
 }
 
-static void removeNullBytes(OutputStream &Output, size_t StartIdx) {
+static void removeNullBytes(OutputString &Output, size_t StartIdx) {
   char *Buffer = Output.getBuffer();
   char *Start = Buffer + StartIdx;
   char *End = Buffer + Output.getCurrentPosition();
   Output.setCurrentPosition(std::remove(Start, End, '\0') - Buffer);
 }
 
 // Encodes code point as UTF-8 and stores results in Output. Returns false if
 // CodePoint is not a valid unicode scalar value.
if (CodePoint <= 0x10FFFF) {
     return true;
   }
 
   return false;
 }
 
 // Decodes string encoded using punycode and appends results to Output.
 // Returns true if decoding was successful.
-static bool decodePunycode(StringView Input, OutputStream &Output) {
+static bool decodePunycode(StringView Input, OutputString &Output) {
   size_t OutputSize = Output.getCurrentPosition();
   size_t InputIdx = 0;
 
   // Rust uses an underscore as a delimiter.
   size_t DelimiterPos = StringView::npos;
   for (size_t I = 0; I != Input.size(); ++I)
     if (Input[I] == '_')
       DelimiterPos = I;

llvm/unittests/Demangle/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Demangle
   Support
 )
 
 add_llvm_unittest(DemangleTests
   DemangleTest.cpp
   ItaniumDemangleTest.cpp
-  OutputStreamTest.cpp
+  OutputStringTest.cpp
   PartialDemangleTest.cpp
   RustDemangleTest.cpp
   StringViewTest.cpp
 )

llvm/unittests/Demangle/ItaniumDemangleTest.cpp

struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {
     }
   };
 
   TestParser Parser("_Z1fIiEjl");
   ASSERT_NE(nullptr, Parser.parse());
   EXPECT_THAT(Parser.Types, testing::ElementsAre('i', 'j', 'l'));
 }
 
-static std::string toString(OutputStream &OS) {
+static std::string toString(OutputString &OS) {
   return {OS.getBuffer(), OS.getCurrentPosition()};
 }
 
 TEST(ItaniumDemangle, HalfType) {
   struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {
     std::vector<std::string> Types;
 
     TestParser(const char *Str)
         : AbstractManglingParser(Str, Str + strlen(Str)) {}
 
     Node *parseType() {
-      OutputStream OS;
+      OutputString OS;
       Node *N = AbstractManglingParser<TestParser, TestAllocator>::parseType();
       N->printLeft(OS);
       StringView Name = N->getBaseName();
       if (!Name.empty())
         Types.push_back(std::string(Name.begin(), Name.end()));
       else
         Types.push_back(toString(OS));
       std::free(OS.getBuffer());

llvm/unittests/Demangle/OutputStringTest.cpp

 //===- llvm/unittest/OutputStreamTest.cpp - OutputStream unit tests -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Demangle/Utility.h"
 #include "gtest/gtest.h"
 #include <string>
 
 using namespace llvm;
-using llvm::itanium_demangle::OutputStream;
+using llvm::itanium_demangle::OutputString;
 
-static std::string toString(OutputStream &OS) {
+static std::string toString(OutputString &OS) {
   return {OS.getBuffer(), OS.getCurrentPosition()};
 }
 
 template <typename T> static std::string printToString(const T &Value) {
-  OutputStream OS;
+  OutputString OS;
   OS << Value;
   std::string s = toString(OS);
   std::free(OS.getBuffer());
   return s;
 }
 
-TEST(OutputStreamTest, Format) {
+TEST(OutputStringTest, Format) {
   EXPECT_EQ("0", printToString(0));
   EXPECT_EQ("1", printToString(1));
   EXPECT_EQ("-1", printToString(-1));
   EXPECT_EQ("-90", printToString(-90));
   EXPECT_EQ("109", printToString(109));
   EXPECT_EQ("400", printToString(400));
 
   EXPECT_EQ("a", printToString('a'));
   EXPECT_EQ("?", printToString('?'));
 
   EXPECT_EQ("abc", printToString("abc"));
 }
 
-TEST(OutputStreamTest, Insert) {
-  OutputStream OS;
+TEST(OutputStringTest, Insert) {
+  OutputString OS;
 
   OS.insert(0, "", 0);
   EXPECT_EQ("", toString(OS));
 
   OS.insert(0, "abcd", 4);
   EXPECT_EQ("abcd", toString(OS));
 
   OS.insert(0, "x", 1);