[MS Demangler] Add output flags to all function calls.

Previously we had a FunctionSigFlags, but it's more flexible
to just have one set of output flags that apply to the entire
process and just pipe the entire set of flags through the
output process.

This will be useful when we start allowing the user to customize
the outputting behavior.

llvm-svn: 340894

3 files changed, 138 insertions, 138 deletions

diff --git a/llvm/lib/Demangle/MicrosoftDemangle.cpp b/llvm/lib/Demangle/MicrosoftDemangle.cpp
index b8b16ef599b..0eb0c6d5883 100644
--- a/llvm/lib/Demangle/MicrosoftDemangle.cpp
+++ b/llvm/lib/Demangle/MicrosoftDemangle.cpp
@@ -994,7 +994,7 @@ Demangler::demangleTemplateInstantiationName(StringView &MangledName,
     // Render this class template name into a string buffer so that we can
     // memorize it for the purpose of back-referencing.
     OutputStream OS = OutputStream::create(nullptr, nullptr, 1024);
-    Identifier->output(OS);
+    Identifier->output(OS, OF_Default);
     OS << '\0';
     char *Name = OS.getBuffer();
 
@@ -1422,7 +1422,7 @@ Demangler::demangleLocallyScopedNamePiece(StringView &MangledName) {
   // Render the parent symbol's name into a buffer.
   OutputStream OS = OutputStream::create(nullptr, nullptr, 1024);
   OS << '`';
-  Scope->output(OS);
+  Scope->output(OS, OF_Default);
   OS << '\'';
   OS << "::`" << Number.first << "'";
   OS << '\0';
@@ -2223,7 +2223,7 @@ void Demangler::dumpBackReferences() {
     OS.setCurrentPosition(0);
 
     TypeNode *T = Backrefs.FunctionParams[I];
-    T->output(OS);
+    T->output(OS, OF_Default);
 
     std::printf("  [%d] - %.*s\n", (int)I, (int)OS.getCurrentPosition(),
                 OS.getBuffer());
@@ -2254,7 +2254,7 @@ char *llvm::microsoftDemangle(const char *MangledName, char *Buf, size_t *N,
     OS << MangledName;
     *Status = llvm::demangle_invalid_mangled_name;
   } else {
-    S->output(OS);
+    S->output(OS, OF_Default);
     *Status = llvm::demangle_success;
   }
 
diff --git a/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp b/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp
index 0e0b01d06b9..9610981e33b 100644
--- a/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp
+++ b/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp
@@ -115,7 +115,7 @@ static void outputCallingConvention(OutputStream &OS, CallingConv CC) {
 
 void TypeNode::outputQuals(bool SpaceBefore, bool SpaceAfter) const {}
 
-void PrimitiveTypeNode::outputPre(OutputStream &OS) const {
+void PrimitiveTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
   switch (PrimKind) {
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Void, "void");
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Bool, "bool");
@@ -141,20 +141,24 @@ void PrimitiveTypeNode::outputPre(OutputStream &OS) const {
   outputQualifiers(OS, Quals, true, false);
 }
 
-void NodeArrayNode::output(OutputStream &OS) const { output(OS, ", "); }
+void NodeArrayNode::output(OutputStream &OS, OutputFlags Flags) const {
+  output(OS, Flags, ", ");
+}
 
-void NodeArrayNode::output(OutputStream &OS, StringView Separator) const {
+void NodeArrayNode::output(OutputStream &OS, OutputFlags Flags,
+                           StringView Separator) const {
   if (Count == 0)
     return;
   if (Nodes[0])
-    Nodes[0]->output(OS);
+    Nodes[0]->output(OS, Flags);
   for (size_t I = 1; I < Count; ++I) {
     OS << Separator;
-    Nodes[I]->output(OS);
+    Nodes[I]->output(OS, Flags);
   }
 }
 
-void EncodedStringLiteralNode::output(OutputStream &OS) const {
+void EncodedStringLiteralNode::output(OutputStream &OS,
+                                      OutputFlags Flags) const {
   switch (Char) {
   case CharKind::Wchar:
     OS << "const wchar_t * {L\"";
@@ -175,20 +179,21 @@ void EncodedStringLiteralNode::output(OutputStream &OS) const {
   OS << "}";
 }
 
-void IntegerLiteralNode::output(OutputStream &OS) const {
+void IntegerLiteralNode::output(OutputStream &OS, OutputFlags Flags) const {
   if (IsNegative)
     OS << '-';
   OS << Value;
 }
 
-void TemplateParameterReferenceNode::output(OutputStream &OS) const {
+void TemplateParameterReferenceNode::output(OutputStream &OS,
+                                            OutputFlags Flags) const {
   if (ThunkOffsetCount > 0)
     OS << "{";
   else if (Affinity == PointerAffinity::Pointer)
     OS << "&";
 
   if (Symbol) {
-    Symbol->output(OS);
+    Symbol->output(OS, Flags);
     if (ThunkOffsetCount > 0)
       OS << ", ";
   }
@@ -202,31 +207,34 @@ void TemplateParameterReferenceNode::output(OutputStream &OS) const {
     OS << "}";
 }
 
-void IdentifierNode::outputTemplateParameters(OutputStream &OS) const {
+void IdentifierNode::outputTemplateParameters(OutputStream &OS,
+                                              OutputFlags Flags) const {
   if (!TemplateParams)
     return;
   OS << "<";
-  TemplateParams->output(OS);
+  TemplateParams->output(OS, Flags);
   OS << ">";
 }
 
-void DynamicStructorIdentifierNode::output(OutputStream &OS) const {
+void DynamicStructorIdentifierNode::output(OutputStream &OS,
+                                           OutputFlags Flags) const {
   if (IsDestructor)
     OS << "`dynamic atexit destructor for ";
   else
     OS << "`dynamic initializer for ";
 
   OS << "'";
-  Name->output(OS);
+  Name->output(OS, Flags);
   OS << "''";
 }
 
-void NamedIdentifierNode::output(OutputStream &OS) const {
+void NamedIdentifierNode::output(OutputStream &OS, OutputFlags Flags) const {
   OS << Name;
-  outputTemplateParameters(OS);
+  outputTemplateParameters(OS, Flags);
 }
 
-void IntrinsicFunctionIdentifierNode::output(OutputStream &OS) const {
+void IntrinsicFunctionIdentifierNode::output(OutputStream &OS,
+                                             OutputFlags Flags) const {
   switch (Operator) {
     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, New, "operator new");
     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Delete, "operator delete");
@@ -322,36 +330,39 @@ void IntrinsicFunctionIdentifierNode::output(OutputStream &OS) const {
   case IntrinsicFunctionKind::None:
     break;
   }
-  outputTemplateParameters(OS);
+  outputTemplateParameters(OS, Flags);
 }
 
-void LocalStaticGuardIdentifierNode::output(OutputStream &OS) const {
+void LocalStaticGuardIdentifierNode::output(OutputStream &OS,
+                                            OutputFlags Flags) const {
   OS << "`local static guard'";
   if (ScopeIndex > 0)
     OS << "{" << ScopeIndex << "}";
 }
 
-void ConversionOperatorIdentifierNode::output(OutputStream &OS) const {
+void ConversionOperatorIdentifierNode::output(OutputStream &OS,
+                                              OutputFlags Flags) const {
   OS << "operator";
-  outputTemplateParameters(OS);
+  outputTemplateParameters(OS, Flags);
   OS << " ";
-  TargetType->output(OS);
+  TargetType->output(OS, Flags);
 }
 
-void StructorIdentifierNode::output(OutputStream &OS) const {
+void StructorIdentifierNode::output(OutputStream &OS, OutputFlags Flags) const {
   if (IsDestructor)
     OS << "~";
-  Class->output(OS);
-  outputTemplateParameters(OS);
+  Class->output(OS, Flags);
+  outputTemplateParameters(OS, Flags);
 }
 
-void LiteralOperatorIdentifierNode::output(OutputStream &OS) const {
+void LiteralOperatorIdentifierNode::output(OutputStream &OS,
+                                           OutputFlags Flags) const {
   OS << "operator \"\"" << Name;
-  outputTemplateParameters(OS);
+  outputTemplateParameters(OS, Flags);
 }
 
 void FunctionSignatureNode::outputPre(OutputStream &OS,
-                                      FunctionSigFlags Flags) const {
+                                      OutputFlags Flags) const {
   if (!(FunctionClass & FC_Global)) {
     if (FunctionClass & FC_Static)
       OS << "static ";
@@ -363,20 +374,20 @@ void FunctionSignatureNode::outputPre(OutputStream &OS,
     OS << "virtual ";
 
   if (ReturnType) {
-    ReturnType->outputPre(OS);
+    ReturnType->outputPre(OS, Flags);
     OS << " ";
   }
 
-  if (!(Flags & FSF_NoCallingConvention))
+  if (!(Flags & OF_NoCallingConvention))
     outputCallingConvention(OS, CallConvention);
 }
 
 void FunctionSignatureNode::outputPost(OutputStream &OS,
-                                       FunctionSigFlags Flags) const {
+                                       OutputFlags Flags) const {
   if (!(FunctionClass & FC_NoParameterList)) {
     OS << "(";
     if (Params)
-      Params->output(OS);
+      Params->output(OS, Flags);
     else
       OS << "void";
     OS << ")";
@@ -397,18 +408,16 @@ void FunctionSignatureNode::outputPost(OutputStream &OS,
     OS << " &&";
 
   if (ReturnType)
-    ReturnType->outputPost(OS);
+    ReturnType->outputPost(OS, Flags);
 }
 
-void ThunkSignatureNode::outputPre(OutputStream &OS,
-                                   FunctionSigFlags Flags) const {
+void ThunkSignatureNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
   OS << "[thunk]: ";
 
   FunctionSignatureNode::outputPre(OS, Flags);
 }
 
-void ThunkSignatureNode::outputPost(OutputStream &OS,
-                                    FunctionSigFlags Flags) const {
+void ThunkSignatureNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
   if (FunctionClass & FC_StaticThisAdjust) {
     OS << "`adjustor{" << ThisAdjust.StaticOffset << "}'";
   } else if (FunctionClass & FC_VirtualThisAdjust) {
@@ -425,15 +434,15 @@ void ThunkSignatureNode::outputPost(OutputStream &OS,
   FunctionSignatureNode::outputPost(OS, Flags);
 }
 
-void PointerTypeNode::outputPre(OutputStream &OS) const {
+void PointerTypeNode::outputPre(OutputStream &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, FSF_NoCallingConvention);
+    Sig->outputPre(OS, OF_NoCallingConvention);
   } else
-    Pointee->outputPre(OS);
+    Pointee->outputPre(OS, Flags);
 
   outputSpaceIfNecessary(OS);
 
@@ -451,7 +460,7 @@ void PointerTypeNode::outputPre(OutputStream &OS) const {
   }
 
   if (ClassParent) {
-    ClassParent->output(OS);
+    ClassParent->output(OS, Flags);
     OS << "::";
   }
 
@@ -471,15 +480,15 @@ void PointerTypeNode::outputPre(OutputStream &OS) const {
   outputQualifiers(OS, Quals, false, false);
 }
 
-void PointerTypeNode::outputPost(OutputStream &OS) const {
+void PointerTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
   if (Pointee->kind() == NodeKind::ArrayType ||
       Pointee->kind() == NodeKind::FunctionSignature)
     OS << ")";
 
-  Pointee->outputPost(OS);
+  Pointee->outputPost(OS, Flags);
 }
 
-void TagTypeNode::outputPre(OutputStream &OS) const {
+void TagTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
   switch (Tag) {
     OUTPUT_ENUM_CLASS_VALUE(TagKind, Class, "class");
     OUTPUT_ENUM_CLASS_VALUE(TagKind, Struct, "struct");
@@ -487,58 +496,57 @@ void TagTypeNode::outputPre(OutputStream &OS) const {
     OUTPUT_ENUM_CLASS_VALUE(TagKind, Enum, "enum");
   }
   OS << " ";
-  QualifiedName->output(OS);
+  QualifiedName->output(OS, Flags);
   outputQualifiers(OS, Quals, true, false);
 }
 
-void TagTypeNode::outputPost(OutputStream &OS) const {}
+void TagTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {}
 
-void ArrayTypeNode::outputPre(OutputStream &OS) const {
-  ElementType->outputPre(OS);
+void ArrayTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
+  ElementType->outputPre(OS, Flags);
   outputQualifiers(OS, Quals, true, false);
 }
 
-void ArrayTypeNode::outputOneDimension(OutputStream &OS, Node *N) const {
+void ArrayTypeNode::outputOneDimension(OutputStream &OS, OutputFlags Flags,
+                                       Node *N) const {
   assert(N->kind() == NodeKind::IntegerLiteral);
   IntegerLiteralNode *ILN = static_cast<IntegerLiteralNode *>(N);
   if (ILN->Value != 0)
-    ILN->output(OS);
+    ILN->output(OS, Flags);
 }
 
-void ArrayTypeNode::outputDimensionsImpl(OutputStream &OS) const {
+void ArrayTypeNode::outputDimensionsImpl(OutputStream &OS,
+                                         OutputFlags Flags) const {
   if (Dimensions->Count == 0)
     return;
 
-  outputOneDimension(OS, Dimensions->Nodes[0]);
+  outputOneDimension(OS, Flags, Dimensions->Nodes[0]);
   for (size_t I = 1; I < Dimensions->Count; ++I) {
     OS << "][";
-    outputOneDimension(OS, Dimensions->Nodes[I]);
+    outputOneDimension(OS, Flags, Dimensions->Nodes[I]);
   }
 }
 
-void ArrayTypeNode::outputPost(OutputStream &OS) const {
+void ArrayTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
   OS << "[";
-  outputDimensionsImpl(OS);
+  outputDimensionsImpl(OS, Flags);
   OS << "]";
 
-  ElementType->outputPost(OS);
+  ElementType->outputPost(OS, Flags);
 }
 
-void SymbolNode::output(OutputStream &OS) const { Name->output(OS); }
-
-void FunctionSymbolNode::output(OutputStream &OS) const {
-  output(OS, FunctionSigFlags::FSF_Default);
+void SymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
+  Name->output(OS, Flags);
 }
 
-void FunctionSymbolNode::output(OutputStream &OS,
-                                FunctionSigFlags Flags) const {
+void FunctionSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
   Signature->outputPre(OS, Flags);
   outputSpaceIfNecessary(OS);
-  Name->output(OS);
+  Name->output(OS, Flags);
   Signature->outputPost(OS, Flags);
 }
 
-void VariableSymbolNode::output(OutputStream &OS) const {
+void VariableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
   switch (SC) {
   case StorageClass::PrivateStatic:
   case StorageClass::PublicStatic:
@@ -549,41 +557,46 @@ void VariableSymbolNode::output(OutputStream &OS) const {
   }
 
   if (Type) {
-    Type->outputPre(OS);
+    Type->outputPre(OS, Flags);
     outputSpaceIfNecessary(OS);
   }
-  Name->output(OS);
+  Name->output(OS, Flags);
   if (Type)
-    Type->outputPost(OS);
+    Type->outputPost(OS, Flags);
 }
 
-void CustomNode::output(OutputStream &OS) const { OS << Name; }
+void CustomNode::output(OutputStream &OS, OutputFlags Flags) const {
+  OS << Name;
+}
 
-void QualifiedNameNode::output(OutputStream &OS) const {
-  Components->output(OS, "::");
+void QualifiedNameNode::output(OutputStream &OS, OutputFlags Flags) const {
+  Components->output(OS, Flags, "::");
 }
 
-void RttiBaseClassDescriptorNode::output(OutputStream &OS) const {
+void RttiBaseClassDescriptorNode::output(OutputStream &OS,
+                                         OutputFlags Flags) const {
   OS << "`RTTI Base Class Descriptor at (";
   OS << NVOffset << ", " << VBPtrOffset << ", " << VBTableOffset << ", "
-     << Flags;
+     << this->Flags;
   OS << ")'";
 }
 
-void LocalStaticGuardVariableNode::output(OutputStream &OS) const {
-  Name->output(OS);
+void LocalStaticGuardVariableNode::output(OutputStream &OS,
+                                          OutputFlags Flags) const {
+  Name->output(OS, Flags);
 }
 
-void VcallThunkIdentifierNode::output(OutputStream &OS) const {
+void VcallThunkIdentifierNode::output(OutputStream &OS,
+                                      OutputFlags Flags) const {
   OS << "`vcall'{" << OffsetInVTable << ", {flat}}";
 }
 
-void SpecialTableSymbolNode::output(OutputStream &OS) const {
+void SpecialTableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
   outputQualifiers(OS, Quals, false, true);
-  Name->output(OS);
+  Name->output(OS, Flags);
   if (TargetName) {
     OS << "{for `";
-    TargetName->output(OS);
+    TargetName->output(OS, Flags);
     OS << "'}";
   }
   return;
diff --git a/llvm/lib/Demangle/MicrosoftDemangleNodes.h b/llvm/lib/Demangle/MicrosoftDemangleNodes.h
index df4679ebb73..1797403cef5 100644
--- a/llvm/lib/Demangle/MicrosoftDemangleNodes.h
+++ b/llvm/lib/Demangle/MicrosoftDemangleNodes.h
@@ -148,7 +148,7 @@ enum class CallingConv : uint8_t {
 
 enum class ReferenceKind : uint8_t { None, LValueRef, RValueRef };
 
-enum FunctionSigFlags { FSF_Default = 0, FSF_NoCallingConvention = 1 };
+enum OutputFlags { OF_Default = 0, OF_NoCallingConvention = 1 };
 
 // Types
 enum class PrimitiveKind {
@@ -328,7 +328,7 @@ struct Node {
 
   NodeKind kind() const { return Kind; }
 
-  virtual void output(OutputStream &OS) const = 0;
+  virtual void output(OutputStream &OS, OutputFlags Flags) const = 0;
 
 private:
   NodeKind Kind;
@@ -365,12 +365,12 @@ struct SpecialTableSymbolNode;
 struct TypeNode : public Node {
   explicit TypeNode(NodeKind K) : Node(K) {}
 
-  virtual void outputPre(OutputStream &OS) const = 0;
-  virtual void outputPost(OutputStream &OS) const = 0;
+  virtual void outputPre(OutputStream &OS, OutputFlags Flags) const = 0;
+  virtual void outputPost(OutputStream &OS, OutputFlags Flags) const = 0;
 
-  void output(OutputStream &OS) const {
-    outputPre(OS);
-    outputPost(OS);
+  void output(OutputStream &OS, OutputFlags Flags) const override {
+    outputPre(OS, Flags);
+    outputPost(OS, Flags);
   }
 
   void outputQuals(bool SpaceBefore, bool SpaceAfter) const;
@@ -382,8 +382,8 @@ struct PrimitiveTypeNode : public TypeNode {
   explicit PrimitiveTypeNode(PrimitiveKind K)
       : TypeNode(NodeKind::PrimitiveType), PrimKind(K) {}
 
-  void outputPre(OutputStream &OS) const;
-  void outputPost(OutputStream &OS) const {}
+  void outputPre(OutputStream &OS, OutputFlags Flags) const;
+  void outputPost(OutputStream &OS, OutputFlags Flags) const {}
 
   PrimitiveKind PrimKind;
 };
@@ -392,20 +392,8 @@ struct FunctionSignatureNode : public TypeNode {
   explicit FunctionSignatureNode(NodeKind K) : TypeNode(K) {}
   FunctionSignatureNode() : TypeNode(NodeKind::FunctionSignature) {}
 
-  virtual void outputPre(OutputStream &OS, FunctionSigFlags Flags) const;
-  virtual void outputPost(OutputStream &OS, FunctionSigFlags Flags) const;
-
-  void outputPre(OutputStream &OS) const override {
-    outputPre(OS, FSF_Default);
-  }
-  void outputPost(OutputStream &OS) const override {
-    outputPost(OS, FSF_Default);
-  }
-
-  void output(OutputStream &OS) const override {
-    outputPre(OS, FSF_Default);
-    outputPost(OS);
-  }
+  virtual void outputPre(OutputStream &OS, OutputFlags Flags) const;
+  virtual void outputPost(OutputStream &OS, OutputFlags Flags) const;
 
   // Valid if this FunctionTypeNode is the Pointee of a PointerType or
   // MemberPointerType.
@@ -435,13 +423,13 @@ struct IdentifierNode : public Node {
   NodeArrayNode *TemplateParams = nullptr;
 
 protected:
-  void outputTemplateParameters(OutputStream &OS) const;
+  void outputTemplateParameters(OutputStream &OS, OutputFlags Flags) const;
 };
 
 struct VcallThunkIdentifierNode : public IdentifierNode {
   VcallThunkIdentifierNode() : IdentifierNode(NodeKind::VcallThunkIdentifier) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   uint64_t OffsetInVTable = 0;
 };
@@ -450,7 +438,7 @@ struct DynamicStructorIdentifierNode : public IdentifierNode {
   DynamicStructorIdentifierNode()
       : IdentifierNode(NodeKind::DynamicStructorIdentifier) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   QualifiedNameNode *Name = nullptr;
   bool IsDestructor = false;
@@ -459,7 +447,7 @@ struct DynamicStructorIdentifierNode : public IdentifierNode {
 struct NamedIdentifierNode : public IdentifierNode {
   NamedIdentifierNode() : IdentifierNode(NodeKind::NamedIdentifier) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   StringView Name;
 };
@@ -469,7 +457,7 @@ struct IntrinsicFunctionIdentifierNode : public IdentifierNode {
       : IdentifierNode(NodeKind::IntrinsicFunctionIdentifier),
         Operator(Operator) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   IntrinsicFunctionKind Operator;
 };
@@ -478,7 +466,7 @@ struct LiteralOperatorIdentifierNode : public IdentifierNode {
   LiteralOperatorIdentifierNode()
       : IdentifierNode(NodeKind::LiteralOperatorIdentifier) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   StringView Name;
 };
@@ -487,7 +475,7 @@ struct LocalStaticGuardIdentifierNode : public IdentifierNode {
   LocalStaticGuardIdentifierNode()
       : IdentifierNode(NodeKind::LocalStaticGuardIdentifier) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   uint32_t ScopeIndex = 0;
 };
@@ -496,7 +484,7 @@ struct ConversionOperatorIdentifierNode : public IdentifierNode {
   ConversionOperatorIdentifierNode()
       : IdentifierNode(NodeKind::ConversionOperatorIdentifier) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   // The type that this operator converts too.
   TypeNode *TargetType = nullptr;
@@ -508,7 +496,7 @@ struct StructorIdentifierNode : public IdentifierNode {
       : IdentifierNode(NodeKind::StructorIdentifier),
         IsDestructor(IsDestructor) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   // The name of the class that this is a structor of.
   IdentifierNode *Class = nullptr;
@@ -518,8 +506,8 @@ struct StructorIdentifierNode : public IdentifierNode {
 struct ThunkSignatureNode : public FunctionSignatureNode {
   ThunkSignatureNode() : FunctionSignatureNode(NodeKind::ThunkSignature) {}
 
-  void outputPre(OutputStream &OS, FunctionSigFlags Flags) const override;
-  void outputPost(OutputStream &OS, FunctionSigFlags Flags) const override;
+  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPost(OutputStream &OS, OutputFlags Flags) const override;
 
   struct ThisAdjustor {
     uint32_t StaticOffset = 0;
@@ -533,8 +521,8 @@ struct ThunkSignatureNode : public FunctionSignatureNode {
 
 struct PointerTypeNode : public TypeNode {
   PointerTypeNode() : TypeNode(NodeKind::PointerType) {}
-  void outputPre(OutputStream &OS) const override;
-  void outputPost(OutputStream &OS) const override;
+  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPost(OutputStream &OS, OutputFlags Flags) const override;
 
   // Is this a pointer, reference, or rvalue-reference?
   PointerAffinity Affinity = PointerAffinity::None;
@@ -550,8 +538,8 @@ struct PointerTypeNode : public TypeNode {
 struct TagTypeNode : public TypeNode {
   explicit TagTypeNode(TagKind Tag) : TypeNode(NodeKind::TagType), Tag(Tag) {}
 
-  void outputPre(OutputStream &OS) const;
-  void outputPost(OutputStream &OS) const;
+  void outputPre(OutputStream &OS, OutputFlags Flags) const;
+  void outputPost(OutputStream &OS, OutputFlags Flags) const;
 
   QualifiedNameNode *QualifiedName = nullptr;
   TagKind Tag;
@@ -560,11 +548,11 @@ struct TagTypeNode : public TypeNode {
 struct ArrayTypeNode : public TypeNode {
   ArrayTypeNode() : TypeNode(NodeKind::ArrayType) {}
 
-  void outputPre(OutputStream &OS) const;
-  void outputPost(OutputStream &OS) const;
+  void outputPre(OutputStream &OS, OutputFlags Flags) const;
+  void outputPost(OutputStream &OS, OutputFlags Flags) const;
 
-  void outputDimensionsImpl(OutputStream &OS) const;
-  void outputOneDimension(OutputStream &OS, Node *N) const;
+  void outputDimensionsImpl(OutputStream &OS, OutputFlags Flags) const;
+  void outputOneDimension(OutputStream &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;
@@ -575,13 +563,13 @@ struct ArrayTypeNode : public TypeNode {
 
 struct IntrinsicNode : public TypeNode {
   IntrinsicNode() : TypeNode(NodeKind::IntrinsicType) {}
-  void output(OutputStream &OS) const override {}
+  void output(OutputStream &OS, OutputFlags Flags) const override {}
 };
 
 struct CustomNode : public Node {
   CustomNode() : Node(NodeKind::Custom) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   // The string to print.
   StringView Name;
@@ -590,9 +578,9 @@ struct CustomNode : public Node {
 struct NodeArrayNode : public Node {
   NodeArrayNode() : Node(NodeKind::NodeArray) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
-  void output(OutputStream &OS, StringView Separator) const;
+  void output(OutputStream &OS, OutputFlags Flags, StringView Separator) const;
 
   Node **Nodes = 0;
   size_t Count = 0;
@@ -601,7 +589,7 @@ struct NodeArrayNode : public Node {
 struct QualifiedNameNode : public Node {
   QualifiedNameNode() : Node(NodeKind::QualifiedName) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   NodeArrayNode *Components = nullptr;
 
@@ -615,7 +603,7 @@ struct TemplateParameterReferenceNode : public Node {
   TemplateParameterReferenceNode()
       : Node(NodeKind::TemplateParameterReference) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   SymbolNode *Symbol = nullptr;
 
@@ -630,7 +618,7 @@ struct IntegerLiteralNode : public Node {
   IntegerLiteralNode(uint64_t Value, bool IsNegative)
       : Node(NodeKind::IntegerLiteral), Value(Value), IsNegative(IsNegative) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   uint64_t Value = 0;
   bool IsNegative = false;
@@ -640,7 +628,7 @@ struct RttiBaseClassDescriptorNode : public IdentifierNode {
   RttiBaseClassDescriptorNode()
       : IdentifierNode(NodeKind::RttiBaseClassDescriptor) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   uint32_t NVOffset = 0;
   int32_t VBPtrOffset = 0;
@@ -650,7 +638,7 @@ struct RttiBaseClassDescriptorNode : public IdentifierNode {
 
 struct SymbolNode : public Node {
   explicit SymbolNode(NodeKind K) : Node(K) {}
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
   QualifiedNameNode *Name = nullptr;
 };
 
@@ -658,7 +646,7 @@ struct SpecialTableSymbolNode : public SymbolNode {
   explicit SpecialTableSymbolNode()
       : SymbolNode(NodeKind::SpecialTableSymbol) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
   QualifiedNameNode *TargetName = nullptr;
   Qualifiers Quals;
 };
@@ -667,7 +655,7 @@ struct LocalStaticGuardVariableNode : public SymbolNode {
   LocalStaticGuardVariableNode()
       : SymbolNode(NodeKind::LocalStaticGuardVariable) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   bool IsVisible = false;
 };
@@ -675,7 +663,7 @@ struct LocalStaticGuardVariableNode : public SymbolNode {
 struct EncodedStringLiteralNode : public SymbolNode {
   EncodedStringLiteralNode() : SymbolNode(NodeKind::EncodedStringLiteral) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   StringView DecodedString;
   bool IsTruncated = false;
@@ -685,7 +673,7 @@ struct EncodedStringLiteralNode : public SymbolNode {
 struct VariableSymbolNode : public SymbolNode {
   VariableSymbolNode() : SymbolNode(NodeKind::VariableSymbol) {}
 
-  void output(OutputStream &OS) const override;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   StorageClass SC = StorageClass::None;
   TypeNode *Type = nullptr;
@@ -694,8 +682,7 @@ struct VariableSymbolNode : public SymbolNode {
 struct FunctionSymbolNode : public SymbolNode {
   FunctionSymbolNode() : SymbolNode(NodeKind::FunctionSymbol) {}
 
-  void output(OutputStream &OS) const override;
-  void output(OutputStream &OS, FunctionSigFlags Flags) const;
+  void output(OutputStream &OS, OutputFlags Flags) const override;
 
   FunctionSignatureNode *Signature = nullptr;
 };