Revise C++ coding style using clang-format

Run the `src/clang-format.bash` script to update all our C and C++
code to a new style defined by `.clang-format`.  Use `clang-format`
version 3.8.  Fix expected test output for new line numbers.

* If you reached this commit for a line in `git blame`, re-run the blame
  operation starting at the parent of this commit to see older history
  for the content.

* See the parent commit for instructions to rebase a change across this
  style transition commit.

1 files changed, 599 insertions, 488 deletions

diff --git a/src/Output.cxx b/src/Output.cxx
index 32ce4b8..55e9ee5 100644
--- a/src/Output.cxx
+++ b/src/Output.cxx
@@ -49,12 +49,17 @@ protected:
   clang::ASTContext const& CTX;
   llvm::raw_ostream& OS;
 
-  ASTVisitorBase(clang::CompilerInstance& ci,
-                 clang::ASTContext const& ctx,
-                 llvm::raw_ostream& os): CI(ci), CTX(ctx), OS(os) {}
+  ASTVisitorBase(clang::CompilerInstance& ci, clang::ASTContext const& ctx,
+                 llvm::raw_ostream& os)
+    : CI(ci)
+    , CTX(ctx)
+    , OS(os)
+  {
+  }
 
   // Represent cv qualifier state of one dump node.
-  struct DumpQual {
+  struct DumpQual
+  {
   private:
     typedef void (DumpQual::*bool_type)() const;
     void bool_true() const {}
@@ -62,12 +67,20 @@ protected:
     bool IsConst;
     bool IsVolatile;
     bool IsRestrict;
-    DumpQual(): IsConst(false), IsVolatile(false), IsRestrict(false) {}
-    operator bool_type() const {
-      return (this->IsConst || this->IsVolatile || this->IsRestrict)?
-        &DumpQual::bool_true : nullptr;
+    DumpQual()
+      : IsConst(false)
+      , IsVolatile(false)
+      , IsRestrict(false)
+    {
     }
-    friend bool operator < (DumpQual const& l, DumpQual const& r) {
+    operator bool_type() const
+    {
+      return (this->IsConst || this->IsVolatile || this->IsRestrict)
+        ? &DumpQual::bool_true
+        : nullptr;
+    }
+    friend bool operator<(DumpQual const& l, DumpQual const& r)
+    {
       if (!l.IsConst && r.IsConst) {
         return true;
       } else if (l.IsConst && !r.IsConst) {
@@ -84,28 +97,39 @@ protected:
         return false;
       }
     }
-    friend llvm::raw_ostream& operator << (llvm::raw_ostream& os,
-                                           DumpQual const& dq) {
-      return os << (dq.IsConst? "c":"")
-                << (dq.IsVolatile? "v":"")
-                << (dq.IsRestrict? "r":"");
+    friend llvm::raw_ostream& operator<<(llvm::raw_ostream& os,
+                                         DumpQual const& dq)
+    {
+      return os << (dq.IsConst ? "c" : "") << (dq.IsVolatile ? "v" : "")
+                << (dq.IsRestrict ? "r" : "");
     }
   };
 
   // Represent id of one dump node.
-  struct DumpId {
+  struct DumpId
+  {
   private:
     typedef void (DumpId::*bool_type)() const;
     void bool_true() const {}
   public:
     unsigned int Id;
     DumpQual Qual;
-    DumpId(): Id(0), Qual() {}
-    DumpId(unsigned int id, DumpQual dq): Id(id), Qual(dq) {}
-    operator bool_type() const {
-      return this->Id != 0? &DumpId::bool_true : nullptr;
+    DumpId()
+      : Id(0)
+      , Qual()
+    {
+    }
+    DumpId(unsigned int id, DumpQual dq)
+      : Id(id)
+      , Qual(dq)
+    {
     }
-    friend bool operator < (DumpId const& l, DumpId const& r) {
+    operator bool_type() const
+    {
+      return this->Id != 0 ? &DumpId::bool_true : nullptr;
+    }
+    friend bool operator<(DumpId const& l, DumpId const& r)
+    {
       if (l.Id < r.Id) {
         return true;
       } else if (l.Id > r.Id) {
@@ -114,15 +138,21 @@ protected:
         return l.Qual < r.Qual;
       }
     }
-    friend llvm::raw_ostream& operator << (llvm::raw_ostream& os,
-                                           DumpId const& id) {
+    friend llvm::raw_ostream& operator<<(llvm::raw_ostream& os,
+                                         DumpId const& id)
+    {
       return os << id.Id << id.Qual;
     }
   };
 
   // Record status of one AST node to be dumped.
-  struct DumpNode {
-    DumpNode(): Index(), Complete(false) {}
+  struct DumpNode
+  {
+    DumpNode()
+      : Index()
+      , Complete(false)
+    {
+    }
 
     // Index in nodes ordered by first encounter.
     DumpId Index;
@@ -131,30 +161,34 @@ protected:
     bool Complete;
   };
 
-  // Report all decl nodes as unimplemented until overridden.
+// Report all decl nodes as unimplemented until overridden.
 #define ABSTRACT_DECL(DECL)
-#define DECL(CLASS, BASE) \
-  void Output##CLASS##Decl(clang::CLASS##Decl const* d, DumpNode const* dn) { \
-    this->OutputUnimplementedDecl(d, dn); \
+#define DECL(CLASS, BASE)                                                     \
+  void Output##CLASS##Decl(clang::CLASS##Decl const* d, DumpNode const* dn)   \
+  {                                                                           \
+    this->OutputUnimplementedDecl(d, dn);                                     \
   }
 #include "clang/AST/DeclNodes.inc"
 
-  void OutputUnimplementedDecl(clang::Decl const* d, DumpNode const* dn) {
+  void OutputUnimplementedDecl(clang::Decl const* d, DumpNode const* dn)
+  {
     /* clang-format off */
     this->OS << "  <Unimplemented id=\"_" << dn->Index
              << "\" kind=\"" << encodeXML(d->getDeclKindName()) << "\"/>\n";
     /* clang-format on */
   }
 
-  // Report all type nodes as unimplemented until overridden.
+// Report all type nodes as unimplemented until overridden.
 #define ABSTRACT_TYPE(CLASS, BASE)
-#define TYPE(CLASS, BASE) \
-  void Output##CLASS##Type(clang::CLASS##Type const* t, DumpNode const* dn) { \
-    this->OutputUnimplementedType(t, dn); \
-    }
+#define TYPE(CLASS, BASE)                                                     \
+  void Output##CLASS##Type(clang::CLASS##Type const* t, DumpNode const* dn)   \
+  {                                                                           \
+    this->OutputUnimplementedType(t, dn);                                     \
+  }
 #include "clang/AST/TypeNodes.def"
 
-  void OutputUnimplementedType(clang::Type const* t, DumpNode const* dn) {
+  void OutputUnimplementedType(clang::Type const* t, DumpNode const* dn)
+  {
     /* clang-format off */
     this->OS << "  <Unimplemented id=\"_" << dn->Index
              << "\" type_class=\"" << encodeXML(t->getTypeClassName())
@@ -163,47 +197,74 @@ protected:
   }
 };
 
-class ASTVisitor: public ASTVisitorBase
+class ASTVisitor : public ASTVisitorBase
 {
   // Store a type to be visited, possibly as a record member.
-  struct DumpType {
-    DumpType(): Type(), Class(0) {}
-    DumpType(clang::QualType t, clang::Type const* c = 0): Type(t), Class(c) {}
-    friend bool operator < (DumpType const& l, DumpType const& r) {
+  struct DumpType
+  {
+    DumpType()
+      : Type()
+      , Class(0)
+    {
+    }
+    DumpType(clang::QualType t, clang::Type const* c = 0)
+      : Type(t)
+      , Class(c)
+    {
+    }
+    friend bool operator<(DumpType const& l, DumpType const& r)
+    {
       // Order by pointer value without discarding low-order
       // bits used to encode qualifiers.
       void const* lpp = &l.Type;
       void const* rpp = &r.Type;
       void const* lpv = *static_cast<void const* const*>(lpp);
       void const* rpv = *static_cast<void const* const*>(rpp);
-      if(lpv < rpv) {
+      if (lpv < rpv) {
         return true;
-      } else if(lpv > rpv) {
+      } else if (lpv > rpv) {
         return false;
       } else {
         return l.Class < r.Class;
       }
     }
 
-    clang::QualType    Type;
+    clang::QualType Type;
     clang::Type const* Class;
   };
 
   // Store an entry in the node traversal queue.
-  struct QueueEntry {
+  struct QueueEntry
+  {
     // Available node kinds.
-    enum Kinds {
+    enum Kinds
+    {
       KindQual,
       KindDecl,
       KindType
     };
 
-    QueueEntry(DumpNode const* dn):
-      Kind(KindQual), Decl(nullptr), Type(), DN(dn) {}
-    QueueEntry(clang::Decl const* d, DumpNode const* dn):
-      Kind(KindDecl), Decl(d), Type(), DN(dn) {}
-    QueueEntry(DumpType t, DumpNode const* dn):
-      Kind(KindType), Decl(nullptr), Type(t), DN(dn) {}
+    QueueEntry(DumpNode const* dn)
+      : Kind(KindQual)
+      , Decl(nullptr)
+      , Type()
+      , DN(dn)
+    {
+    }
+    QueueEntry(clang::Decl const* d, DumpNode const* dn)
+      : Kind(KindDecl)
+      , Decl(d)
+      , Type()
+      , DN(dn)
+    {
+    }
+    QueueEntry(DumpType t, DumpNode const* dn)
+      : Kind(KindType)
+      , Decl(nullptr)
+      , Type(t)
+      , DN(dn)
+    {
+    }
 
     // Kind of node at this entry.
     Kinds Kind;
@@ -217,32 +278,36 @@ class ASTVisitor: public ASTVisitorBase
     // The dump status for this node.
     DumpNode const* DN;
 
-    friend bool operator < (QueueEntry const& l, QueueEntry const& r) {
+    friend bool operator<(QueueEntry const& l, QueueEntry const& r)
+    {
       return l.DN->Index < r.DN->Index;
     }
   };
 
-  class PrinterHelper: public clang::PrinterHelper {
+  class PrinterHelper : public clang::PrinterHelper
+  {
     ASTVisitor& Visitor;
+
   public:
-    PrinterHelper(ASTVisitor& v): Visitor(v) {}
-    bool handledStmt(clang::Stmt* s, llvm::raw_ostream& os) override {
+    PrinterHelper(ASTVisitor& v)
+      : Visitor(v)
+    {
+    }
+    bool handledStmt(clang::Stmt* s, llvm::raw_ostream& os) override
+    {
       return this->Visitor.PrintHelpStmt(s, os);
     }
   };
 
   /** Get the dump status node for a Clang declaration.  */
-  DumpNode* GetDumpNode(clang::Decl const* d) {
-    return &this->DeclNodes[d];
-  }
+  DumpNode* GetDumpNode(clang::Decl const* d) { return &this->DeclNodes[d]; }
 
   /** Get the dump status node for a Clang type.  */
-  DumpNode* GetDumpNode(DumpType t) {
-    return &this->TypeNodes[t];
-  }
+  DumpNode* GetDumpNode(DumpType t) { return &this->TypeNodes[t]; }
 
   /** Get the dump status node for a qualified DumpId.  */
-  DumpNode* GetDumpNode(DumpId id) {
+  DumpNode* GetDumpNode(DumpId id)
+  {
     assert(id.Qual);
     return &this->QualNodes[id];
   }
@@ -260,7 +325,8 @@ class ASTVisitor: public ASTVisitorBase
   DumpId AddQualDumpNode(DumpId id);
 
   /** Helper common to AddDeclDumpNode and AddTypeDumpNode.  */
-  template <typename K> DumpId AddDumpNodeImpl(K k, bool complete);
+  template <typename K>
+  DumpId AddDumpNodeImpl(K k, bool complete);
 
   /** Allocate a dump node for a source file entry.  */
   unsigned int AddDumpFile(clang::FileEntry const* f);
@@ -385,13 +451,14 @@ class ASTVisitor: public ASTVisitorBase
 
   /** Flags used by function output methods to pass information
       to the OutputFunctionHelper method.  */
-  enum FunctionHelperFlags {
-    FH_Returns    = (1<<0),
-    FH_Static     = (1<<1),
-    FH_Explicit   = (1<<2),
-    FH_Const      = (1<<3),
-    FH_Virtual    = (1<<4),
-    FH_Pure       = (1<<5),
+  enum FunctionHelperFlags
+  {
+    FH_Returns = (1 << 0),
+    FH_Static = (1 << 1),
+    FH_Explicit = (1 << 2),
+    FH_Const = (1 << 3),
+    FH_Virtual = (1 << 4),
+    FH_Pure = (1 << 5),
     FH__Last
   };
 
@@ -516,17 +583,17 @@ private:
   std::queue<clang::FileEntry const*> FileQueue;
 
 public:
-  ASTVisitor(clang::CompilerInstance& ci,
-             clang::ASTContext& ctx,
-             llvm::raw_ostream& os,
-             Options const& opts):
-    ASTVisitorBase(ci, ctx, os),
-    Opts(opts),
-    NodeCount(0), FileCount(0),
-    FileBuiltin(false),
-    RequireComplete(true),
-    MangleContext(ctx.createMangleContext()),
-    PrintingPolicy(ctx.getPrintingPolicy()) {
+  ASTVisitor(clang::CompilerInstance& ci, clang::ASTContext& ctx,
+             llvm::raw_ostream& os, Options const& opts)
+    : ASTVisitorBase(ci, ctx, os)
+    , Opts(opts)
+    , NodeCount(0)
+    , FileCount(0)
+    , FileBuiltin(false)
+    , RequireComplete(true)
+    , MangleContext(ctx.createMangleContext())
+    , PrintingPolicy(ctx.getPrintingPolicy())
+  {
     this->PrintingPolicy.SuppressUnwrittenScope = true;
   }
 
@@ -536,29 +603,30 @@ public:
 };
 
 ASTVisitor::DumpId ASTVisitor::AddDeclDumpNode(clang::Decl const* d,
-                                               bool complete, bool forType) {
+                                               bool complete, bool forType)
+{
   // Select the definition or canonical declaration.
   d = d->getCanonicalDecl();
-  if(clang::RecordDecl const* rd = clang::dyn_cast<clang::RecordDecl>(d)) {
-    if(clang::RecordDecl const* rdd = rd->getDefinition()) {
+  if (clang::RecordDecl const* rd = clang::dyn_cast<clang::RecordDecl>(d)) {
+    if (clang::RecordDecl const* rdd = rd->getDefinition()) {
       d = rdd;
     }
   }
 
   // Replace some decls with those they reference.
   switch (d->getKind()) {
-  case clang::Decl::UsingShadow:
-    return this->AddDeclDumpNode(
-      static_cast<clang::UsingShadowDecl const*>(d)->getTargetDecl(),
-      complete, forType);
-  case clang::Decl::LinkageSpec: {
-    clang::DeclContext const* dc =
-      static_cast<clang::LinkageSpecDecl const*>(d)->getDeclContext();
-    return this->AddDeclDumpNode(clang::Decl::castFromDeclContext(dc),
-                                 complete, forType);
-  } break;
-  default:
-    break;
+    case clang::Decl::UsingShadow:
+      return this->AddDeclDumpNode(
+        static_cast<clang::UsingShadowDecl const*>(d)->getTargetDecl(),
+        complete, forType);
+    case clang::Decl::LinkageSpec: {
+      clang::DeclContext const* dc =
+        static_cast<clang::LinkageSpecDecl const*>(d)->getDeclContext();
+      return this->AddDeclDumpNode(clang::Decl::castFromDeclContext(dc),
+                                   complete, forType);
+    } break;
+    default:
+      break;
   }
 
   // Skip invalid declarations that are not needed for a type element.
@@ -569,7 +637,7 @@ ASTVisitor::DumpId ASTVisitor::AddDeclDumpNode(clang::Decl const* d,
   // Skip C++11 declarations gccxml does not support.
   if (this->Opts.GccXml) {
     if (clang::FunctionDecl const* fd =
-        clang::dyn_cast<clang::FunctionDecl>(d)) {
+          clang::dyn_cast<clang::FunctionDecl>(d)) {
       if (fd->isDeleted()) {
         return DumpId();
       }
@@ -579,14 +647,15 @@ ASTVisitor::DumpId ASTVisitor::AddDeclDumpNode(clang::Decl const* d,
       }
 
       if (clang::FunctionProtoType const* fpt =
-          fd->getType()->getAs<clang::FunctionProtoType>()) {
+            fd->getType()->getAs<clang::FunctionProtoType>()) {
         if (fpt->getReturnType()->isRValueReferenceType()) {
           return DumpId();
         }
         for (clang::FunctionProtoType::param_type_iterator
-               i = fpt->param_type_begin(), e = fpt->param_type_end();
+               i = fpt->param_type_begin(),
+               e = fpt->param_type_end();
              i != e; ++i) {
-          if((*i)->isRValueReferenceType()) {
+          if ((*i)->isRValueReferenceType()) {
             return DumpId();
           }
         }
@@ -602,7 +671,7 @@ ASTVisitor::DumpId ASTVisitor::AddDeclDumpNode(clang::Decl const* d,
     }
 
     if (clang::TypedefDecl const* td =
-        clang::dyn_cast<clang::TypedefDecl>(d)) {
+          clang::dyn_cast<clang::TypedefDecl>(d)) {
       if (td->getUnderlyingType()->isRValueReferenceType()) {
         return DumpId();
       }
@@ -614,7 +683,8 @@ ASTVisitor::DumpId ASTVisitor::AddDeclDumpNode(clang::Decl const* d,
 
 ASTVisitor::DumpId ASTVisitor::AddDeclDumpNodeForType(clang::Decl const* d,
                                                       bool complete,
-                                                      DumpQual dq) {
+                                                      DumpQual dq)
+{
   // Get the id for the canonical decl.
   DumpId id = this->AddDeclDumpNode(d, complete, true);
 
@@ -628,12 +698,13 @@ ASTVisitor::DumpId ASTVisitor::AddDeclDumpNodeForType(clang::Decl const* d,
 }
 
 ASTVisitor::DumpId ASTVisitor::AddTypeDumpNode(DumpType dt, bool complete,
-                                               DumpQual dq) {
+                                               DumpQual dq)
+{
   clang::QualType t = dt.Type;
   clang::Type const* c = dt.Class;
 
   // Extract local qualifiers and recurse with locally unqualified type.
-  if(t.hasLocalQualifiers()) {
+  if (t.hasLocalQualifiers()) {
     dq.IsConst = dq.IsConst || t.isLocalConstQualified();
     dq.IsVolatile = dq.IsVolatile || t.isLocalVolatileQualified();
     dq.IsRestrict = dq.IsRestrict || t.isLocalRestrictQualified();
@@ -643,72 +714,74 @@ ASTVisitor::DumpId ASTVisitor::AddTypeDumpNode(DumpType dt, bool complete,
 
   // Replace some types with their decls.
   switch (t->getTypeClass()) {
-  case clang::Type::Adjusted:
-    return this->AddTypeDumpNode(DumpType(
-      t->getAs<clang::AdjustedType>()->getAdjustedType(), c),
-      complete, dq);
-  case clang::Type::Attributed:
-    return this->AddTypeDumpNode(DumpType(
-      t->getAs<clang::AttributedType>()->getEquivalentType(), c),
-      complete, dq);
-  case clang::Type::Decayed:
-    return this->AddTypeDumpNode(DumpType(
-      t->getAs<clang::DecayedType>()->getDecayedType(), c),
-      complete, dq);
-  case clang::Type::Elaborated:
-    return this->AddTypeDumpNode(DumpType(
-      t->getAs<clang::ElaboratedType>()->getNamedType(), c),
-      complete, dq);
-  case clang::Type::Enum:
-    return this->AddDeclDumpNodeForType(
-      t->getAs<clang::EnumType>()->getDecl(), complete, dq);
-  case clang::Type::Paren:
-    return this->AddTypeDumpNode(DumpType(
-      t->getAs<clang::ParenType>()->getInnerType(), c),
-      complete, dq);
-  case clang::Type::Record:
-    return this->AddDeclDumpNodeForType(
-      t->getAs<clang::RecordType>()->getDecl(), complete, dq);
-  case clang::Type::SubstTemplateTypeParm:
-    return this->AddTypeDumpNode(DumpType(
-      t->getAs<clang::SubstTemplateTypeParmType>()->getReplacementType(), c),
-      complete, dq);
-  case clang::Type::TemplateSpecialization: {
-    clang::TemplateSpecializationType const* tst =
-      t->getAs<clang::TemplateSpecializationType>();
-    if(tst->isSugared()) {
-      return this->AddTypeDumpNode(DumpType(tst->desugar(), c),
-                                   complete, dq);
-    }
-  } break;
-  case clang::Type::Typedef: {
-    clang::TypedefType const* tdt = t->getAs<clang::TypedefType>();
-    if(!tdt->isInstantiationDependentType() && tdt->isSugared()) {
-      // Make sure all containing contexts are not templates.
-      clang::Decl const* d = tdt->getDecl();
-      while (clang::DeclContext const* tdc = d->getDeclContext()) {
-        if (clang::CXXRecordDecl const* tdx =
-            clang::dyn_cast<clang::CXXRecordDecl>(tdc)) {
-          d = tdx;
-          if (tdx->getDescribedClassTemplate() ||
-              clang::isa<clang::ClassTemplatePartialSpecializationDecl>(tdx)
-             ) {
-            // This TypedefType refers to a non-dependent
-            // TypedefDecl member of a class template.  Since gccxml
-            // format does not include uninstantiated templates we
-            // must use the desugared type so that we do not end up
-            // referencing a class template as context.
-            return this->AddTypeDumpNode(tdt->desugar(), complete, dq);
+    case clang::Type::Adjusted:
+      return this->AddTypeDumpNode(
+        DumpType(t->getAs<clang::AdjustedType>()->getAdjustedType(), c),
+        complete, dq);
+    case clang::Type::Attributed:
+      return this->AddTypeDumpNode(
+        DumpType(t->getAs<clang::AttributedType>()->getEquivalentType(), c),
+        complete, dq);
+    case clang::Type::Decayed:
+      return this->AddTypeDumpNode(
+        DumpType(t->getAs<clang::DecayedType>()->getDecayedType(), c),
+        complete, dq);
+    case clang::Type::Elaborated:
+      return this->AddTypeDumpNode(
+        DumpType(t->getAs<clang::ElaboratedType>()->getNamedType(), c),
+        complete, dq);
+    case clang::Type::Enum:
+      return this->AddDeclDumpNodeForType(
+        t->getAs<clang::EnumType>()->getDecl(), complete, dq);
+    case clang::Type::Paren:
+      return this->AddTypeDumpNode(
+        DumpType(t->getAs<clang::ParenType>()->getInnerType(), c), complete,
+        dq);
+    case clang::Type::Record:
+      return this->AddDeclDumpNodeForType(
+        t->getAs<clang::RecordType>()->getDecl(), complete, dq);
+    case clang::Type::SubstTemplateTypeParm:
+      return this->AddTypeDumpNode(
+        DumpType(
+          t->getAs<clang::SubstTemplateTypeParmType>()->getReplacementType(),
+          c),
+        complete, dq);
+    case clang::Type::TemplateSpecialization: {
+      clang::TemplateSpecializationType const* tst =
+        t->getAs<clang::TemplateSpecializationType>();
+      if (tst->isSugared()) {
+        return this->AddTypeDumpNode(DumpType(tst->desugar(), c), complete,
+                                     dq);
+      }
+    } break;
+    case clang::Type::Typedef: {
+      clang::TypedefType const* tdt = t->getAs<clang::TypedefType>();
+      if (!tdt->isInstantiationDependentType() && tdt->isSugared()) {
+        // Make sure all containing contexts are not templates.
+        clang::Decl const* d = tdt->getDecl();
+        while (clang::DeclContext const* tdc = d->getDeclContext()) {
+          if (clang::CXXRecordDecl const* tdx =
+                clang::dyn_cast<clang::CXXRecordDecl>(tdc)) {
+            d = tdx;
+            if (tdx->getDescribedClassTemplate() ||
+                clang::isa<clang::ClassTemplatePartialSpecializationDecl>(
+                  tdx)) {
+              // This TypedefType refers to a non-dependent
+              // TypedefDecl member of a class template.  Since gccxml
+              // format does not include uninstantiated templates we
+              // must use the desugared type so that we do not end up
+              // referencing a class template as context.
+              return this->AddTypeDumpNode(tdt->desugar(), complete, dq);
+            }
+          } else {
+            break;
           }
-        } else {
-          break;
         }
       }
-    }
-    return this->AddDeclDumpNodeForType(tdt->getDecl(), complete, dq);
-  } break;
-  default:
-    break;
+      return this->AddDeclDumpNodeForType(tdt->getDecl(), complete, dq);
+    } break;
+    default:
+      break;
   }
 
   // Get the id for the fully desugared, unqualified type.
@@ -723,7 +796,8 @@ ASTVisitor::DumpId ASTVisitor::AddTypeDumpNode(DumpType dt, bool complete,
   return id;
 }
 
-ASTVisitor::DumpId ASTVisitor::AddQualDumpNode(DumpId id) {
+ASTVisitor::DumpId ASTVisitor::AddQualDumpNode(DumpId id)
+{
   DumpNode* dn = this->GetDumpNode(id);
   if (!dn->Index) {
     dn->Index = id;
@@ -741,7 +815,7 @@ ASTVisitor::DumpId ASTVisitor::AddDumpNodeImpl(K k, bool complete)
   DumpNode* dn = this->GetDumpNode(k);
   if (dn->Index) {
     // Node was already encountered.  See if it is now complete.
-    if(complete && !dn->Complete) {
+    if (complete && !dn->Complete) {
       // Node is now complete, but wasn't before.  Queue it.
       dn->Complete = true;
       this->Queue.insert(QueueEntry(k, dn));
@@ -750,7 +824,7 @@ ASTVisitor::DumpId ASTVisitor::AddDumpNodeImpl(K k, bool complete)
     // This is a new node.  Assign it an index.
     dn->Index.Id = ++this->NodeCount;
     dn->Complete = complete;
-    if(complete || !this->RequireComplete) {
+    if (complete || !this->RequireComplete) {
       // Node is complete.  Queue it.
       this->Queue.insert(QueueEntry(k, dn));
     }
@@ -762,7 +836,7 @@ ASTVisitor::DumpId ASTVisitor::AddDumpNodeImpl(K k, bool complete)
 unsigned int ASTVisitor::AddDumpFile(clang::FileEntry const* f)
 {
   unsigned int& index = this->FileNodes[f];
-  if(index == 0) {
+  if (index == 0) {
     index = ++this->FileCount;
     this->FileQueue.push(f);
   }
@@ -773,11 +847,12 @@ void ASTVisitor::AddClassTemplateDecl(clang::ClassTemplateDecl const* d,
                                       std::set<DumpId>* emitted)
 {
   // Queue all the instantiations of this class template.
-  for(clang::ClassTemplateDecl::spec_iterator i = d->spec_begin(),
-        e = d->spec_end(); i != e; ++i) {
+  for (clang::ClassTemplateDecl::spec_iterator i = d->spec_begin(),
+                                               e = d->spec_end();
+       i != e; ++i) {
     clang::CXXRecordDecl const* rd = *i;
     DumpId id = this->AddDeclDumpNode(rd, true);
-    if(id && emitted) {
+    if (id && emitted) {
       emitted->insert(id);
     }
   }
@@ -787,11 +862,12 @@ void ASTVisitor::AddFunctionTemplateDecl(clang::FunctionTemplateDecl const* d,
                                          std::set<DumpId>* emitted)
 {
   // Queue all the instantiations of this function template.
-  for(clang::FunctionTemplateDecl::spec_iterator i = d->spec_begin(),
-        e = d->spec_end(); i != e; ++i) {
+  for (clang::FunctionTemplateDecl::spec_iterator i = d->spec_begin(),
+                                                  e = d->spec_end();
+       i != e; ++i) {
     clang::FunctionDecl const* fd = *i;
     DumpId id = this->AddDeclDumpNode(fd, true);
-    if(id && emitted) {
+    if (id && emitted) {
       emitted->insert(id);
     }
   }
@@ -802,12 +878,13 @@ void ASTVisitor::AddDeclContextMembers(clang::DeclContext const* dc,
 {
   bool const isTranslationUnit = clang::isa<clang::TranslationUnitDecl>(dc);
 
-  for(clang::DeclContext::decl_iterator i = dc->decls_begin(),
-        e = dc->decls_end(); i != e; ++i) {
+  for (clang::DeclContext::decl_iterator i = dc->decls_begin(),
+                                         e = dc->decls_end();
+       i != e; ++i) {
     clang::Decl const* d = *i;
 
     // Skip declarations that are not really members of this context.
-    if(d->getDeclContext() != dc) {
+    if (d->getDeclContext() != dc) {
       continue;
     }
 
@@ -824,60 +901,60 @@ void ASTVisitor::AddDeclContextMembers(clang::DeclContext const* dc,
 
     // Ignore certain members.
     switch (d->getKind()) {
-    case clang::Decl::CXXRecord: {
-      clang::CXXRecordDecl const* rd =
-        static_cast<clang::CXXRecordDecl const*>(d);
-      if (rd->isInjectedClassName()) {
+      case clang::Decl::CXXRecord: {
+        clang::CXXRecordDecl const* rd =
+          static_cast<clang::CXXRecordDecl const*>(d);
+        if (rd->isInjectedClassName()) {
+          continue;
+        }
+      } break;
+      case clang::Decl::AccessSpec: {
         continue;
-      }
-    } break;
-    case clang::Decl::AccessSpec: {
-      continue;
-    } break;
-    case clang::Decl::ClassTemplate: {
-      this->AddClassTemplateDecl(
-        static_cast<clang::ClassTemplateDecl const*>(d), &emitted);
-      continue;
-    } break;
-    case clang::Decl::ClassTemplatePartialSpecialization: {
-      continue;
-    } break;
-    case clang::Decl::Empty: {
-      continue;
-    } break;
-    case clang::Decl::Friend: {
-      continue;
-    } break;
-    case clang::Decl::FunctionTemplate: {
-      this->AddFunctionTemplateDecl(
-        static_cast<clang::FunctionTemplateDecl const*>(d), &emitted);
-      continue;
-    } break;
-    case clang::Decl::LinkageSpec: {
-      this->AddDeclContextMembers(
-        static_cast<clang::LinkageSpecDecl const*>(d), emitted);
-      continue;
-    } break;
-    case clang::Decl::Namespace: {
-      clang::NamespaceDecl const* nd =
-        static_cast<clang::NamespaceDecl const*>(d);
-      if (nd->isInline()) {
-        this->AddDeclContextMembers(nd, emitted);
+      } break;
+      case clang::Decl::ClassTemplate: {
+        this->AddClassTemplateDecl(
+          static_cast<clang::ClassTemplateDecl const*>(d), &emitted);
         continue;
-      }
-    } break;
-    case clang::Decl::Using: {
-      continue;
-    } break;
-    case clang::Decl::UsingDirective: {
-      continue;
-    } break;
-    default:
-      break;
+      } break;
+      case clang::Decl::ClassTemplatePartialSpecialization: {
+        continue;
+      } break;
+      case clang::Decl::Empty: {
+        continue;
+      } break;
+      case clang::Decl::Friend: {
+        continue;
+      } break;
+      case clang::Decl::FunctionTemplate: {
+        this->AddFunctionTemplateDecl(
+          static_cast<clang::FunctionTemplateDecl const*>(d), &emitted);
+        continue;
+      } break;
+      case clang::Decl::LinkageSpec: {
+        this->AddDeclContextMembers(
+          static_cast<clang::LinkageSpecDecl const*>(d), emitted);
+        continue;
+      } break;
+      case clang::Decl::Namespace: {
+        clang::NamespaceDecl const* nd =
+          static_cast<clang::NamespaceDecl const*>(d);
+        if (nd->isInline()) {
+          this->AddDeclContextMembers(nd, emitted);
+          continue;
+        }
+      } break;
+      case clang::Decl::Using: {
+        continue;
+      } break;
+      case clang::Decl::UsingDirective: {
+        continue;
+      } break;
+      default:
+        break;
     }
 
     // Queue this decl and print its id.
-    if(DumpId id = this->AddDeclDumpNode(d, true)) {
+    if (DumpId id = this->AddDeclDumpNode(d, true)) {
       emitted.insert(id);
     }
   }
@@ -886,46 +963,49 @@ void ASTVisitor::AddDeclContextMembers(clang::DeclContext const* dc,
 void ASTVisitor::AddStartDecl(clang::Decl const* d)
 {
   switch (d->getKind()) {
-  case clang::Decl::ClassTemplate:
-    this->AddClassTemplateDecl(
-      static_cast<clang::ClassTemplateDecl const*>(d));
-    break;
-  case clang::Decl::FunctionTemplate:
-    this->AddFunctionTemplateDecl(
-      static_cast<clang::FunctionTemplateDecl const*>(d));
-    break;
-  case clang::Decl::Namespace: {
-    if (!static_cast<clang::NamespaceDecl const*>(d)->isInline()) {
-      this->AddDeclDumpNode(d, true);
-    }
-  } break;
-  case clang::Decl::Using: {
+    case clang::Decl::ClassTemplate:
+      this->AddClassTemplateDecl(
+        static_cast<clang::ClassTemplateDecl const*>(d));
+      break;
+    case clang::Decl::FunctionTemplate:
+      this->AddFunctionTemplateDecl(
+        static_cast<clang::FunctionTemplateDecl const*>(d));
+      break;
+    case clang::Decl::Namespace: {
+      if (!static_cast<clang::NamespaceDecl const*>(d)->isInline()) {
+        this->AddDeclDumpNode(d, true);
+      }
+    } break;
+    case clang::Decl::Using: {
       clang::UsingDecl const* ud = static_cast<clang::UsingDecl const*>(d);
-      for(clang::UsingDecl::shadow_iterator i = ud->shadow_begin(),
-            e = ud->shadow_end(); i != e; ++i) {
+      for (clang::UsingDecl::shadow_iterator i = ud->shadow_begin(),
+                                             e = ud->shadow_end();
+           i != e; ++i) {
         this->AddDeclDumpNode(*i, true);
       }
-  } break;
-  default:
-    this->AddDeclDumpNode(d, true);
-    break;
+    } break;
+    default:
+      this->AddDeclDumpNode(d, true);
+      break;
   }
 }
 
 void ASTVisitor::QueueIncompleteDumpNodes()
 {
   // Queue declaration nodes that do not need complete output.
-  for(DeclNodesMap::const_iterator i = this->DeclNodes.begin(),
-        e = this->DeclNodes.end(); i != e; ++i) {
-    if(!i->second.Complete) {
+  for (DeclNodesMap::const_iterator i = this->DeclNodes.begin(),
+                                    e = this->DeclNodes.end();
+       i != e; ++i) {
+    if (!i->second.Complete) {
       this->Queue.insert(QueueEntry(i->first, &i->second));
     }
   }
 
   // Queue type nodes that do not need complete output.
-  for(TypeNodesMap::const_iterator i = this->TypeNodes.begin(),
-        e = this->TypeNodes.end(); i != e; ++i) {
-    if(!i->second.Complete) {
+  for (TypeNodesMap::const_iterator i = this->TypeNodes.begin(),
+                                    e = this->TypeNodes.end();
+       i != e; ++i) {
+    if (!i->second.Complete) {
       this->Queue.insert(QueueEntry(i->first, &i->second));
     }
   }
@@ -934,33 +1014,33 @@ void ASTVisitor::QueueIncompleteDumpNodes()
 void ASTVisitor::ProcessQueue()
 {
   // Dispatch each entry in the queue based on its node kind.
-  while(!this->Queue.empty()) {
+  while (!this->Queue.empty()) {
     QueueEntry qe = *this->Queue.begin();
     this->Queue.erase(this->Queue.begin());
-    switch(qe.Kind) {
-    case QueueEntry::KindQual:
-      this->OutputCvQualifiedType(qe.DN);
-      break;
-    case QueueEntry::KindDecl:
-      this->OutputDecl(qe.Decl, qe.DN);
-      break;
-    case QueueEntry::KindType:
-      this->OutputType(qe.Type, qe.DN);
-      break;
+    switch (qe.Kind) {
+      case QueueEntry::KindQual:
+        this->OutputCvQualifiedType(qe.DN);
+        break;
+      case QueueEntry::KindDecl:
+        this->OutputDecl(qe.Decl, qe.DN);
+        break;
+      case QueueEntry::KindType:
+        this->OutputType(qe.Type, qe.DN);
+        break;
     }
   }
 }
 
 void ASTVisitor::ProcessFileQueue()
 {
-  if(this->FileBuiltin) {
+  if (this->FileBuiltin) {
     /* clang-format off */
     this->OS <<
       "  <File id=\"f0\" name=\"" << encodeXML("<builtin>") << "\"/>\n"
       ;
     /* clang-format on */
   }
-  while(!this->FileQueue.empty()) {
+  while (!this->FileQueue.empty()) {
     clang::FileEntry const* f = this->FileQueue.front();
     this->FileQueue.pop();
     /* clang-format off */
@@ -979,10 +1059,9 @@ void ASTVisitor::OutputDecl(clang::Decl const* d, DumpNode const* dn)
   // Dispatch output of the declaration.
   switch (d->getKind()) {
 #define ABSTRACT_DECL(DECL)
-#define DECL(CLASS, BASE) \
-  case clang::Decl::CLASS: \
-    this->Output##CLASS##Decl( \
-      static_cast<clang::CLASS##Decl const*>(d), dn); \
+#define DECL(CLASS, BASE)                                                     \
+  case clang::Decl::CLASS:                                                    \
+    this->Output##CLASS##Decl(static_cast<clang::CLASS##Decl const*>(d), dn); \
     break;
 #include "clang/AST/DeclNodes.inc"
   }
@@ -993,18 +1072,18 @@ void ASTVisitor::OutputType(DumpType dt, DumpNode const* dn)
   clang::QualType t = dt.Type;
   clang::Type const* c = dt.Class;
 
-  if(c) {
+  if (c) {
     // Output the method type.
     this->OutputMethodType(t->getAs<clang::FunctionProtoType>(), c, dn);
   } else {
     // Dispatch output of the unqualified type.
     switch (t->getTypeClass()) {
 #define ABSTRACT_TYPE(CLASS, BASE)
-#define TYPE(CLASS, BASE) \
-      case clang::Type::CLASS: \
-        this->Output##CLASS##Type( \
-          static_cast<clang::CLASS##Type const*>(t.getTypePtr()), dn); \
-        break;
+#define TYPE(CLASS, BASE)                                                     \
+  case clang::Type::CLASS:                                                    \
+    this->Output##CLASS##Type(                                                \
+      static_cast<clang::CLASS##Type const*>(t.getTypePtr()), dn);            \
+    break;
 #include "clang/AST/TypeNodes.def"
     }
   }
@@ -1040,7 +1119,7 @@ ASTVisitor::DumpId ASTVisitor::GetContextIdRef(clang::DeclContext const* dc)
     dc = dc->getParent();
   }
 
-  if(clang::Decl const* d = clang::dyn_cast<clang::Decl>(dc)) {
+  if (clang::Decl const* d = clang::dyn_cast<clang::Decl>(dc)) {
     return this->AddDeclDumpNode(d, false);
   } else {
     return DumpId();
@@ -1050,7 +1129,7 @@ ASTVisitor::DumpId ASTVisitor::GetContextIdRef(clang::DeclContext const* dc)
 std::string ASTVisitor::GetContextName(clang::CXXMethodDecl const* d)
 {
   clang::DeclContext const* dc = d->getDeclContext();
-  if(clang::RecordDecl const* rd = clang::dyn_cast<clang::RecordDecl>(dc)) {
+  if (clang::RecordDecl const* rd = clang::dyn_cast<clang::RecordDecl>(dc)) {
     return rd->getName().str();
   }
   return "";
@@ -1106,9 +1185,9 @@ void ASTVisitor::PrintOffsetAttribute(unsigned int const& offset)
 
 void ASTVisitor::PrintABIAttributes(clang::TypeDecl const* d)
 {
-  if(clang::TypeDecl const* td = clang::dyn_cast<clang::TypeDecl>(d)) {
+  if (clang::TypeDecl const* td = clang::dyn_cast<clang::TypeDecl>(d)) {
     clang::Type const* ty = td->getTypeForDecl();
-    if(!ty->isIncompleteType()) {
+    if (!ty->isIncompleteType()) {
       this->PrintABIAttributes(this->CTX.getTypeInfo(ty));
     }
   }
@@ -1144,10 +1223,10 @@ void ASTVisitor::PrintReturnsAttribute(clang::QualType t, bool complete)
 void ASTVisitor::PrintLocationAttribute(clang::Decl const* d)
 {
   clang::SourceLocation sl = d->getLocation();
-  if(sl.isValid()) {
+  if (sl.isValid()) {
     clang::FullSourceLoc fsl = this->CTX.getFullLoc(sl).getExpansionLoc();
     if (clang::FileEntry const* f =
-        this->CI.getSourceManager().getFileEntryForID(fsl.getFileID())) {
+          this->CI.getSourceManager().getFileEntryForID(fsl.getFileID())) {
       unsigned int id = this->AddDumpFile(f);
       unsigned int line = fsl.getExpansionLineNumber();
       /* clang-format off */
@@ -1159,7 +1238,7 @@ void ASTVisitor::PrintLocationAttribute(clang::Decl const* d)
       return;
     }
   }
-  if(d->isImplicit()) {
+  if (d->isImplicit()) {
     this->FileBuiltin = true;
     this->OS << " location=\"f0:0\" file=\"f0\" line=\"0\"";
   }
@@ -1168,58 +1247,58 @@ void ASTVisitor::PrintLocationAttribute(clang::Decl const* d)
 bool ASTVisitor::PrintHelpStmt(clang::Stmt const* s, llvm::raw_ostream& os)
 {
   switch (s->getStmtClass()) {
-  case clang::Stmt::CStyleCastExprClass: {
-    // Duplicate clang::StmtPrinter::VisitCStyleCastExpr
-    // but with canonical type so we do not print an unqualified name.
-    clang::CStyleCastExpr const* e =
-      static_cast<clang::CStyleCastExpr const*>(s);
-    os << "(";
-    e->getTypeAsWritten().getCanonicalType().print(os, this->PrintingPolicy);
-    os << ")";
-    PrinterHelper ph(*this);
-    e->getSubExpr()->printPretty(os, &ph, this->PrintingPolicy);
-    return true;
-  } break;
-  case clang::Stmt::CXXConstCastExprClass: // fallthrough
-  case clang::Stmt::CXXDynamicCastExprClass: // fallthrough
-  case clang::Stmt::CXXReinterpretCastExprClass: // fallthrough
-  case clang::Stmt::CXXStaticCastExprClass: {
-    // Duplicate clang::StmtPrinter::VisitCXXNamedCastExpr
-    // but with canonical type so we do not print an unqualified name.
-    clang::CXXNamedCastExpr const* e =
-      static_cast<clang::CXXNamedCastExpr const*>(s);
-    os << e->getCastName() << '<';
-    e->getTypeAsWritten().getCanonicalType().print(os, this->PrintingPolicy);
-    os << ">(";
-    PrinterHelper ph(*this);
-    e->getSubExpr()->printPretty(os, &ph, this->PrintingPolicy);
-    os << ")";
-    return true;
-  } break;
-  case clang::Stmt::DeclRefExprClass: {
-    // Print the fully qualified name of the referenced declaration.
-    clang::DeclRefExpr const* e = static_cast<clang::DeclRefExpr const*>(s);
-    if (clang::NamedDecl const* d =
-        clang::dyn_cast<clang::NamedDecl>(e->getDecl())) {
-      std::string s;
-      {
-        llvm::raw_string_ostream rso(s);
-        d->printQualifiedName(rso, this->PrintingPolicy);
-        rso.str();
-      }
-      if (clang::isa<clang::EnumConstantDecl>(d)) {
-        // Clang does not exclude the "::" after an unnamed enum type.
-        std::string::size_type pos = s.find("::::");
-        if (pos != s.npos) {
-          s.erase(pos, 2);
+    case clang::Stmt::CStyleCastExprClass: {
+      // Duplicate clang::StmtPrinter::VisitCStyleCastExpr
+      // but with canonical type so we do not print an unqualified name.
+      clang::CStyleCastExpr const* e =
+        static_cast<clang::CStyleCastExpr const*>(s);
+      os << "(";
+      e->getTypeAsWritten().getCanonicalType().print(os, this->PrintingPolicy);
+      os << ")";
+      PrinterHelper ph(*this);
+      e->getSubExpr()->printPretty(os, &ph, this->PrintingPolicy);
+      return true;
+    } break;
+    case clang::Stmt::CXXConstCastExprClass:       // fallthrough
+    case clang::Stmt::CXXDynamicCastExprClass:     // fallthrough
+    case clang::Stmt::CXXReinterpretCastExprClass: // fallthrough
+    case clang::Stmt::CXXStaticCastExprClass: {
+      // Duplicate clang::StmtPrinter::VisitCXXNamedCastExpr
+      // but with canonical type so we do not print an unqualified name.
+      clang::CXXNamedCastExpr const* e =
+        static_cast<clang::CXXNamedCastExpr const*>(s);
+      os << e->getCastName() << '<';
+      e->getTypeAsWritten().getCanonicalType().print(os, this->PrintingPolicy);
+      os << ">(";
+      PrinterHelper ph(*this);
+      e->getSubExpr()->printPretty(os, &ph, this->PrintingPolicy);
+      os << ")";
+      return true;
+    } break;
+    case clang::Stmt::DeclRefExprClass: {
+      // Print the fully qualified name of the referenced declaration.
+      clang::DeclRefExpr const* e = static_cast<clang::DeclRefExpr const*>(s);
+      if (clang::NamedDecl const* d =
+            clang::dyn_cast<clang::NamedDecl>(e->getDecl())) {
+        std::string s;
+        {
+          llvm::raw_string_ostream rso(s);
+          d->printQualifiedName(rso, this->PrintingPolicy);
+          rso.str();
+        }
+        if (clang::isa<clang::EnumConstantDecl>(d)) {
+          // Clang does not exclude the "::" after an unnamed enum type.
+          std::string::size_type pos = s.find("::::");
+          if (pos != s.npos) {
+            s.erase(pos, 2);
+          }
         }
+        os << s;
+        return true;
       }
-      os << s;
-      return true;
-    }
-  } break;
-  default:
-    break;
+    } break;
+    default:
+      break;
   }
   return false;
 }
@@ -1227,17 +1306,17 @@ bool ASTVisitor::PrintHelpStmt(clang::Stmt const* s, llvm::raw_ostream& os)
 void ASTVisitor::PrintAccessAttribute(clang::AccessSpecifier as)
 {
   switch (as) {
-  case clang::AS_private:
-    this->OS << " access=\"private\"";
-    break;
-  case clang::AS_protected:
-    this->OS << " access=\"protected\"";
-    break;
-  case clang::AS_public:
-    this->OS << " access=\"public\"";
-    break;
-  case clang::AS_none:
-    break;
+    case clang::AS_private:
+      this->OS << " access=\"private\"";
+      break;
+    case clang::AS_protected:
+      this->OS << " access=\"protected\"";
+      break;
+    case clang::AS_public:
+      this->OS << " access=\"public\"";
+      break;
+    case clang::AS_none:
+      break;
   }
 }
 
@@ -1245,11 +1324,11 @@ void ASTVisitor::PrintContextAttribute(clang::Decl const* d,
                                        clang::AccessSpecifier alt)
 {
   clang::DeclContext const* dc = d->getDeclContext();
-  if(DumpId id = this->GetContextIdRef(dc)) {
+  if (DumpId id = this->GetContextIdRef(dc)) {
     this->OS << " context=\"_" << id << "\"";
     if (dc->isRecord()) {
       clang::AccessSpecifier as = d->getAccess();
-      this->PrintAccessAttribute(as != clang::AS_none? as : alt);
+      this->PrintAccessAttribute(as != clang::AS_none ? as : alt);
     }
   }
 }
@@ -1263,11 +1342,12 @@ void ASTVisitor::PrintMembersAttribute(clang::DeclContext const* dc)
 
 void ASTVisitor::PrintMembersAttribute(std::set<DumpId> const& emitted)
 {
-  if(!emitted.empty()) {
+  if (!emitted.empty()) {
     this->OS << " members=\"";
     const char* sep = "";
-    for(std::set<DumpId>::const_iterator i = emitted.begin(),
-          e = emitted.end(); i != e; ++i) {
+    for (std::set<DumpId>::const_iterator i = emitted.begin(),
+                                          e = emitted.end();
+         i != e; ++i) {
       this->OS << sep << "_" << *i;
       sep = " ";
     }
@@ -1279,14 +1359,20 @@ void ASTVisitor::PrintBasesAttribute(clang::CXXRecordDecl const* dx)
 {
   this->OS << " bases=\"";
   const char* sep = "";
-  for(clang::CXXRecordDecl::base_class_const_iterator i = dx->bases_begin(),
-        e = dx->bases_end(); i != e; ++i) {
+  for (clang::CXXRecordDecl::base_class_const_iterator i = dx->bases_begin(),
+                                                       e = dx->bases_end();
+       i != e; ++i) {
     this->OS << sep;
     sep = " ";
     switch (i->getAccessSpecifier()) {
-    case clang::AS_private: this->OS << "private:"; break;
-    case clang::AS_protected: this->OS << "protected:"; break;
-    default: break;
+      case clang::AS_private:
+        this->OS << "private:";
+        break;
+      case clang::AS_protected:
+        this->OS << "protected:";
+        break;
+      default:
+        break;
     }
     this->PrintTypeIdRef(i->getType().getCanonicalType(), true);
   }
@@ -1301,7 +1387,7 @@ void ASTVisitor::PrintAttributesAttribute(
   }
   this->OS << " attributes=\"";
   const char* sep = "";
-  for (std::string const& a: attrs) {
+  for (std::string const& a : attrs) {
     this->OS << sep << encodeXML(a);
     sep = " ";
   }
@@ -1319,26 +1405,26 @@ void ASTVisitor::GetFunctionTypeAttributes(clang::FunctionProtoType const* t,
                                            std::vector<std::string>& attrs)
 {
   switch (t->getExtInfo().getCC()) {
-  case clang::CallingConv::CC_C:
-    break;
-  case clang::CallingConv::CC_X86StdCall:
-    attrs.push_back("__stdcall__");
-    break;
-  case clang::CallingConv::CC_X86FastCall:
-    attrs.push_back("__fastcall__");
-    break;
-  case clang::CallingConv::CC_X86ThisCall:
-    attrs.push_back("__thiscall__");
-    break;
-  default:
-    break;
+    case clang::CallingConv::CC_C:
+      break;
+    case clang::CallingConv::CC_X86StdCall:
+      attrs.push_back("__stdcall__");
+      break;
+    case clang::CallingConv::CC_X86FastCall:
+      attrs.push_back("__fastcall__");
+      break;
+    case clang::CallingConv::CC_X86ThisCall:
+      attrs.push_back("__thiscall__");
+      break;
+    default:
+      break;
   }
 }
 
 void ASTVisitor::GetDeclAttributes(clang::Decl const* d,
                                    std::vector<std::string>& attrs)
 {
-  for (auto const* a: d->specific_attrs<clang::AnnotateAttr>()) {
+  for (auto const* a : d->specific_attrs<clang::AnnotateAttr>()) {
     attrs.push_back("annotate(" + a->getAnnotation().str() + ")");
   }
 }
@@ -1346,12 +1432,12 @@ void ASTVisitor::GetDeclAttributes(clang::Decl const* d,
 void ASTVisitor::PrintThrowsAttribute(clang::FunctionProtoType const* fpt,
                                       bool complete)
 {
-  if(fpt && fpt->hasDynamicExceptionSpec()) {
+  if (fpt && fpt->hasDynamicExceptionSpec()) {
     clang::FunctionProtoType::exception_iterator i = fpt->exception_begin();
     clang::FunctionProtoType::exception_iterator e = fpt->exception_end();
     this->OS << " throw=\"";
     const char* sep = "";
-    for(;i != e; ++i) {
+    for (; i != e; ++i) {
       this->OS << sep;
       this->PrintTypeIdRef(*i, complete);
       sep = " ";
@@ -1362,23 +1448,24 @@ void ASTVisitor::PrintThrowsAttribute(clang::FunctionProtoType const* fpt,
 
 void ASTVisitor::PrintBefriendingAttribute(clang::CXXRecordDecl const* dx)
 {
-  if(dx && dx->hasFriends()) {
+  if (dx && dx->hasFriends()) {
     this->OS << " befriending=\"";
     const char* sep = "";
-    for(clang::CXXRecordDecl::friend_iterator i = dx->friend_begin(),
-          e = dx->friend_end(); i != e; ++i) {
+    for (clang::CXXRecordDecl::friend_iterator i = dx->friend_begin(),
+                                               e = dx->friend_end();
+         i != e; ++i) {
       clang::FriendDecl const* fd = *i;
-      if(clang::NamedDecl const* nd = fd->getFriendDecl()) {
-        if(nd->isTemplateDecl()) {
+      if (clang::NamedDecl const* nd = fd->getFriendDecl()) {
+        if (nd->isTemplateDecl()) {
           // gccxml output format does not have uninstantiated templates
           continue;
         }
 
-        if(DumpId id = this->AddDeclDumpNode(nd, false)) {
+        if (DumpId id = this->AddDeclDumpNode(nd, false)) {
           this->OS << sep << "_" << id;
           sep = " ";
         }
-      } else if(clang::TypeSourceInfo const* tsi = fd->getFriendType()) {
+      } else if (clang::TypeSourceInfo const* tsi = fd->getFriendType()) {
         this->OS << sep;
         this->PrintTypeIdRef(tsi->getType(), false);
         sep = " ";
@@ -1396,49 +1483,48 @@ void ASTVisitor::PrintFloat128Type(DumpNode const* dn)
 }
 
 void ASTVisitor::OutputFunctionHelper(clang::FunctionDecl const* d,
-                                      DumpNode const* dn,
-                                      const char* tag,
+                                      DumpNode const* dn, const char* tag,
                                       std::string const& name,
                                       unsigned int flags)
 {
   this->OS << "  <" << tag;
   this->PrintIdAttribute(dn);
-  if(!name.empty()) {
+  if (!name.empty()) {
     this->PrintNameAttribute(name);
   }
-  if(flags & FH_Returns) {
+  if (flags & FH_Returns) {
     this->PrintReturnsAttribute(d->getReturnType(), dn->Complete);
   }
   this->PrintContextAttribute(d);
   this->PrintLocationAttribute(d);
 
-  if(flags & FH_Static) {
+  if (flags & FH_Static) {
     this->OS << " static=\"1\"";
   }
-  if(flags & FH_Explicit) {
+  if (flags & FH_Explicit) {
     this->OS << " explicit=\"1\"";
   }
-  if(flags & FH_Const) {
+  if (flags & FH_Const) {
     this->OS << " const=\"1\"";
   }
-  if(flags & FH_Virtual) {
+  if (flags & FH_Virtual) {
     this->OS << " virtual=\"1\"";
   }
-  if(flags & FH_Pure) {
+  if (flags & FH_Pure) {
     this->OS << " pure_virtual=\"1\"";
   }
-  if(d->isInlined()) {
+  if (d->isInlined()) {
     this->OS << " inline=\"1\"";
   }
-  if(d->getStorageClass() == clang::SC_Extern) {
+  if (d->getStorageClass() == clang::SC_Extern) {
     this->OS << " extern=\"1\"";
   }
-  if(d->isImplicit()) {
+  if (d->isImplicit()) {
     this->OS << " artificial=\"1\"";
   }
 
   if (clang::CXXMethodDecl const* md =
-      clang::dyn_cast<clang::CXXMethodDecl>(d)) {
+        clang::dyn_cast<clang::CXXMethodDecl>(d)) {
     if (md->size_overridden_methods() > 0) {
       this->OS << " overrides=\"";
       const char* sep = "";
@@ -1458,7 +1544,7 @@ void ASTVisitor::OutputFunctionHelper(clang::FunctionDecl const* d,
   std::vector<std::string> attributes;
 
   if (clang::FunctionProtoType const* fpt =
-      d->getType()->getAs<clang::FunctionProtoType>()) {
+        d->getType()->getAs<clang::FunctionProtoType>()) {
     this->PrintThrowsAttribute(fpt, dn->Complete);
     if (!clang::isa<clang::CXXConstructorDecl>(d) &&
         !clang::isa<clang::CXXDestructorDecl>(d)) {
@@ -1470,7 +1556,7 @@ void ASTVisitor::OutputFunctionHelper(clang::FunctionDecl const* d,
   this->GetDeclAttributes(d, attributes);
   this->PrintAttributesAttribute(attributes);
 
-  if(unsigned np = d->getNumParams()) {
+  if (unsigned np = d->getNumParams()) {
     this->OS << ">\n";
     for (unsigned i = 0; i < np; ++i) {
       // Use the default argument from the most recent declaration.
@@ -1478,14 +1564,14 @@ void ASTVisitor::OutputFunctionHelper(clang::FunctionDecl const* d,
       // them all.
       clang::ParmVarDecl const* pd = d->getMostRecentDecl()->getParamDecl(i);
       clang::Expr const* def = pd->getInit();
-      if(!def && pd->hasUninstantiatedDefaultArg()) {
+      if (!def && pd->hasUninstantiatedDefaultArg()) {
         def = pd->getUninstantiatedDefaultArg();
       }
 
       // Use the parameter located in the canonical declaration.
       this->OutputFunctionArgument(d->getParamDecl(i), dn->Complete, def);
     }
-    if(d->isVariadic()) {
+    if (d->isVariadic()) {
       this->OS << "    <Ellipsis/>\n";
     }
     this->OS << "  </" << tag << ">\n";
@@ -1500,31 +1586,33 @@ void ASTVisitor::OutputFunctionTypeHelper(clang::FunctionProtoType const* t,
 {
   this->OS << "  <" << tag;
   this->PrintIdAttribute(dn);
-  if(c) {
+  if (c) {
     this->PrintBaseTypeAttribute(c, dn->Complete);
   }
   this->PrintReturnsAttribute(t->getReturnType(), dn->Complete);
-  if(t->isConst()) {
+  if (t->isConst()) {
     this->OS << " const=\"1\"";
   }
-  if(t->isVolatile()) {
+  if (t->isVolatile()) {
     this->OS << " volatile=\"1\"";
   }
-  if(t->isRestrict()) {
+  if (t->isRestrict()) {
     this->OS << " restrict=\"1\"";
   }
   std::vector<std::string> attributes;
   this->GetFunctionTypeAttributes(t, attributes);
   this->PrintAttributesAttribute(attributes);
-  if(t->param_type_begin() != t->param_type_end()) {
+  if (t->param_type_begin() != t->param_type_end()) {
     this->OS << ">\n";
     for (clang::FunctionProtoType::param_type_iterator
-           i = t->param_type_begin(), e = t->param_type_end(); i != e; ++i) {
+           i = t->param_type_begin(),
+           e = t->param_type_end();
+         i != e; ++i) {
       this->OS << "    <Argument";
       this->PrintTypeAttribute(*i, dn->Complete);
       this->OS << "/>\n";
     }
-    if(t->isVariadic()) {
+    if (t->isVariadic()) {
       this->OS << "    <Ellipsis/>\n";
     }
     this->OS << "  </" << tag << ">\n";
@@ -1538,12 +1626,12 @@ void ASTVisitor::OutputFunctionArgument(clang::ParmVarDecl const* a,
 {
   this->OS << "    <Argument";
   std::string name = a->getName().str();
-  if(!name.empty()) {
+  if (!name.empty()) {
     this->PrintNameAttribute(name);
   }
   this->PrintTypeAttribute(a->getType(), complete);
   this->PrintLocationAttribute(a);
-  if(def) {
+  if (def) {
     this->OS << " default=\"";
     std::string s;
     llvm::raw_string_ostream rso(s);
@@ -1556,20 +1644,20 @@ void ASTVisitor::OutputFunctionArgument(clang::ParmVarDecl const* a,
   this->OS << "/>\n";
 }
 
-void ASTVisitor::OutputTranslationUnitDecl(
-  clang::TranslationUnitDecl const* d, DumpNode const* dn)
+void ASTVisitor::OutputTranslationUnitDecl(clang::TranslationUnitDecl const* d,
+                                           DumpNode const* dn)
 {
   this->OS << "  <Namespace";
   this->PrintIdAttribute(dn);
   this->PrintNameAttribute("::");
-  if(dn->Complete) {
+  if (dn->Complete) {
     this->PrintMembersAttribute(d);
   }
   this->OS << "/>\n";
 }
 
-void ASTVisitor::OutputNamespaceDecl(
-  clang::NamespaceDecl const* d, DumpNode const* dn)
+void ASTVisitor::OutputNamespaceDecl(clang::NamespaceDecl const* d,
+                                     DumpNode const* dn)
 {
   this->OS << "  <Namespace";
   this->PrintIdAttribute(dn);
@@ -1578,9 +1666,9 @@ void ASTVisitor::OutputNamespaceDecl(
     this->PrintNameAttribute(name);
   }
   this->PrintContextAttribute(d);
-  if(dn->Complete) {
+  if (dn->Complete) {
     std::set<DumpId> emitted;
-    for (clang::NamespaceDecl const* r: d->redecls()) {
+    for (clang::NamespaceDecl const* r : d->redecls()) {
       this->AddDeclContextMembers(r, emitted);
     }
     this->PrintMembersAttribute(emitted);
@@ -1593,18 +1681,26 @@ void ASTVisitor::OutputRecordDecl(clang::RecordDecl const* d,
 {
   const char* tag;
   switch (d->getTagKind()) {
-  case clang::TTK_Class: tag = "Class"; break;
-  case clang::TTK_Union: tag = "Union"; break;
-  case clang::TTK_Struct: tag = "Struct"; break;
-  case clang::TTK_Interface: return;
-  case clang::TTK_Enum: return;
+    case clang::TTK_Class:
+      tag = "Class";
+      break;
+    case clang::TTK_Union:
+      tag = "Union";
+      break;
+    case clang::TTK_Struct:
+      tag = "Struct";
+      break;
+    case clang::TTK_Interface:
+      return;
+    case clang::TTK_Enum:
+      return;
   }
   clang::CXXRecordDecl const* dx = clang::dyn_cast<clang::CXXRecordDecl>(d);
   bool doBases = false;
 
   this->OS << "  <" << tag;
   this->PrintIdAttribute(dn);
-  if(!d->isAnonymousStructOrUnion()) {
+  if (!d->isAnonymousStructOrUnion()) {
     std::string s;
     llvm::raw_string_ostream rso(s);
     d->getNameForDiagnostic(rso, this->PrintingPolicy, false);
@@ -1612,24 +1708,23 @@ void ASTVisitor::OutputRecordDecl(clang::RecordDecl const* d,
   }
   clang::AccessSpecifier access = clang::AS_none;
   if (clang::ClassTemplateSpecializationDecl const* dxts =
-      clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(d)) {
+        clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(d)) {
     // This is a template instantiation so get the access of the original
     // template.  Access of the instantiation itself has no meaning.
-    if (clang::ClassTemplateDecl const* dxt =
-        dxts->getSpecializedTemplate()) {
+    if (clang::ClassTemplateDecl const* dxt = dxts->getSpecializedTemplate()) {
       access = dxt->getAccess();
     }
   }
   this->PrintContextAttribute(d, access);
   this->PrintLocationAttribute(d);
-  if(d->getDefinition()) {
-    if(dx && dx->isAbstract()) {
+  if (d->getDefinition()) {
+    if (dx && dx->isAbstract()) {
       this->OS << " abstract=\"1\"";
     }
     if (dn->Complete && !d->isInvalidDecl()) {
       this->PrintMembersAttribute(d);
       doBases = dx && dx->getNumBases();
-      if(doBases) {
+      if (doBases) {
         this->PrintBasesAttribute(dx);
       }
       this->PrintBefriendingAttribute(dx);
@@ -1639,21 +1734,22 @@ void ASTVisitor::OutputRecordDecl(clang::RecordDecl const* d,
   }
   this->PrintABIAttributes(d);
   this->PrintAttributesAttribute(d);
-  if(doBases) {
+  if (doBases) {
     this->OS << ">\n";
     clang::ASTRecordLayout const& layout = this->CTX.getASTRecordLayout(dx);
-    for(clang::CXXRecordDecl::base_class_const_iterator i = dx->bases_begin(),
-          e = dx->bases_end(); i != e; ++i) {
+    for (clang::CXXRecordDecl::base_class_const_iterator i = dx->bases_begin(),
+                                                         e = dx->bases_end();
+         i != e; ++i) {
       clang::QualType bt = i->getType().getCanonicalType();
       clang::CXXRecordDecl const* bd = clang::dyn_cast<clang::CXXRecordDecl>(
         bt->getAs<clang::RecordType>()->getDecl());
       this->OS << "    <Base";
       this->PrintTypeAttribute(bt, true);
       this->PrintAccessAttribute(i->getAccessSpecifier());
-      this->OS << " virtual=\"" << (i->isVirtual()? 1 : 0) << "\"";
+      this->OS << " virtual=\"" << (i->isVirtual() ? 1 : 0) << "\"";
       if (bd && !i->isVirtual()) {
-        this->OS << " offset=\"" <<
-          layout.getBaseClassOffset(bd).getQuantity() << "\"";
+        this->OS << " offset=\"" << layout.getBaseClassOffset(bd).getQuantity()
+                 << "\"";
       }
       this->OS << "/>\n";
     }
@@ -1666,7 +1762,7 @@ void ASTVisitor::OutputRecordDecl(clang::RecordDecl const* d,
 void ASTVisitor::OutputCXXRecordDecl(clang::CXXRecordDecl const* d,
                                      DumpNode const* dn)
 {
-  if(d->getDescribedClassTemplate()) {
+  if (d->getDescribedClassTemplate()) {
     // We do not implement class template output yet.
     this->ASTVisitorBase::OutputCXXRecordDecl(d, dn);
     return;
@@ -1713,8 +1809,8 @@ void ASTVisitor::OutputEnumDecl(clang::EnumDecl const* d, DumpNode const* dn)
   this->OS << "  <Enumeration";
   this->PrintIdAttribute(dn);
   std::string name = d->getName().str();
-  if(name.empty()) {
-    if(clang::TypedefNameDecl const* td = d->getTypedefNameForAnonDecl()) {
+  if (name.empty()) {
+    if (clang::TypedefNameDecl const* td = d->getTypedefNameForAnonDecl()) {
       name = td->getName().str();
     }
   }
@@ -1724,10 +1820,10 @@ void ASTVisitor::OutputEnumDecl(clang::EnumDecl const* d, DumpNode const* dn)
   this->PrintAttributesAttribute(d);
   clang::EnumDecl::enumerator_iterator enum_begin = d->enumerator_begin();
   clang::EnumDecl::enumerator_iterator enum_end = d->enumerator_end();
-  if(enum_begin != enum_end) {
+  if (enum_begin != enum_end) {
     this->OS << ">\n";
-    for(clang::EnumDecl::enumerator_iterator i = enum_begin;
-        i != enum_end; ++i) {
+    for (clang::EnumDecl::enumerator_iterator i = enum_begin; i != enum_end;
+         ++i) {
       clang::EnumConstantDecl const* ecd = *i;
       this->OS << "    <EnumValue";
       this->PrintNameAttribute(ecd->getName());
@@ -1747,14 +1843,14 @@ void ASTVisitor::OutputFieldDecl(clang::FieldDecl const* d, DumpNode const* dn)
   this->PrintIdAttribute(dn);
   this->PrintNameAttribute(d->getName().str());
   this->PrintTypeAttribute(d->getType(), dn->Complete);
-  if(d->isBitField()) {
+  if (d->isBitField()) {
     unsigned bits = d->getBitWidthValue(this->CTX);
     this->OS << " bits=\"" << bits << "\"";
   }
   this->PrintContextAttribute(d);
   this->PrintLocationAttribute(d);
   this->PrintOffsetAttribute(this->CTX.getFieldOffset(d));
-  if(d->isMutable()) {
+  if (d->isMutable()) {
     this->OS << " mutable=\"1\"";
   }
   this->PrintAttributesAttribute(d);
@@ -1768,7 +1864,7 @@ void ASTVisitor::OutputVarDecl(clang::VarDecl const* d, DumpNode const* dn)
   this->PrintIdAttribute(dn);
   this->PrintNameAttribute(d->getName().str());
   this->PrintTypeAttribute(d->getType(), dn->Complete);
-  if(clang::Expr const* init = d->getInit()) {
+  if (clang::Expr const* init = d->getInit()) {
     this->OS << " init=\"";
     std::string s;
     llvm::raw_string_ostream rso(s);
@@ -1779,10 +1875,10 @@ void ASTVisitor::OutputVarDecl(clang::VarDecl const* d, DumpNode const* dn)
   }
   this->PrintContextAttribute(d);
   this->PrintLocationAttribute(d);
-  if(d->getStorageClass() == clang::SC_Static) {
+  if (d->getStorageClass() == clang::SC_Static) {
     this->OS << " static=\"1\"";
   }
-  if(d->getStorageClass() == clang::SC_Extern) {
+  if (d->getStorageClass() == clang::SC_Extern) {
     this->OS << " extern=\"1\"";
   }
   this->PrintMangledAttribute(d);
@@ -1794,18 +1890,19 @@ void ASTVisitor::OutputVarDecl(clang::VarDecl const* d, DumpNode const* dn)
 void ASTVisitor::OutputFunctionDecl(clang::FunctionDecl const* d,
                                     DumpNode const* dn)
 {
-  if(d->getDescribedFunctionTemplate()) {
+  if (d->getDescribedFunctionTemplate()) {
     // We do not implement function template output yet.
     this->ASTVisitorBase::OutputFunctionDecl(d, dn);
     return;
   }
 
   unsigned int flags = FH_Returns;
-  if(d->getStorageClass() == clang::SC_Static) {
+  if (d->getStorageClass() == clang::SC_Static) {
     flags |= FH_Static;
   }
-  if(d->isOverloadedOperator()) {
-    this->OutputFunctionHelper(d, dn, "OperatorFunction",
+  if (d->isOverloadedOperator()) {
+    this->OutputFunctionHelper(
+      d, dn, "OperatorFunction",
       clang::getOperatorSpelling(d->getOverloadedOperator()), flags);
   } else if (clang::IdentifierInfo const* ii = d->getIdentifier()) {
     this->OutputFunctionHelper(d, dn, "Function", ii->getName().str(), flags);
@@ -1817,27 +1914,28 @@ void ASTVisitor::OutputFunctionDecl(clang::FunctionDecl const* d,
 void ASTVisitor::OutputCXXMethodDecl(clang::CXXMethodDecl const* d,
                                      DumpNode const* dn)
 {
-  if(d->getDescribedFunctionTemplate()) {
+  if (d->getDescribedFunctionTemplate()) {
     // We do not implement function template output yet.
     this->ASTVisitorBase::OutputCXXMethodDecl(d, dn);
     return;
   }
 
   unsigned int flags = FH_Returns;
-  if(d->isStatic()) {
+  if (d->isStatic()) {
     flags |= FH_Static;
   }
-  if(d->isConst()) {
+  if (d->isConst()) {
     flags |= FH_Const;
   }
-  if(d->isVirtual()) {
+  if (d->isVirtual()) {
     flags |= FH_Virtual;
   }
-  if(d->isPure()) {
+  if (d->isPure()) {
     flags |= FH_Pure;
   }
-  if(d->isOverloadedOperator()) {
-    this->OutputFunctionHelper(d, dn, "OperatorMethod",
+  if (d->isOverloadedOperator()) {
+    this->OutputFunctionHelper(
+      d, dn, "OperatorMethod",
       clang::getOperatorSpelling(d->getOverloadedOperator()), flags);
   } else if (clang::IdentifierInfo const* ii = d->getIdentifier()) {
     this->OutputFunctionHelper(d, dn, "Method", ii->getName().str(), flags);
@@ -1849,20 +1947,20 @@ void ASTVisitor::OutputCXXMethodDecl(clang::CXXMethodDecl const* d,
 void ASTVisitor::OutputCXXConversionDecl(clang::CXXConversionDecl const* d,
                                          DumpNode const* dn)
 {
-  if(d->getDescribedFunctionTemplate()) {
+  if (d->getDescribedFunctionTemplate()) {
     // We do not implement function template output yet.
     this->ASTVisitorBase::OutputCXXConversionDecl(d, dn);
     return;
   }
 
   unsigned int flags = FH_Returns;
-  if(d->isConst()) {
+  if (d->isConst()) {
     flags |= FH_Const;
   }
-  if(d->isVirtual()) {
+  if (d->isVirtual()) {
     flags |= FH_Virtual;
   }
-  if(d->isPure()) {
+  if (d->isPure()) {
     flags |= FH_Pure;
   }
   this->OutputFunctionHelper(d, dn, "Converter", "", flags);
@@ -1871,38 +1969,38 @@ void ASTVisitor::OutputCXXConversionDecl(clang::CXXConversionDecl const* d,
 void ASTVisitor::OutputCXXConstructorDecl(clang::CXXConstructorDecl const* d,
                                           DumpNode const* dn)
 {
-  if(d->getDescribedFunctionTemplate()) {
+  if (d->getDescribedFunctionTemplate()) {
     // We do not implement function template output yet.
     this->ASTVisitorBase::OutputCXXConstructorDecl(d, dn);
     return;
   }
 
   unsigned int flags = 0;
-  if(d->isExplicit()) {
+  if (d->isExplicit()) {
     flags |= FH_Explicit;
   }
-  this->OutputFunctionHelper(d, dn, "Constructor",
-                             this->GetContextName(d), flags);
+  this->OutputFunctionHelper(d, dn, "Constructor", this->GetContextName(d),
+                             flags);
 }
 
 void ASTVisitor::OutputCXXDestructorDecl(clang::CXXDestructorDecl const* d,
                                          DumpNode const* dn)
 {
-  if(d->getDescribedFunctionTemplate()) {
+  if (d->getDescribedFunctionTemplate()) {
     // We do not implement function template output yet.
     this->ASTVisitorBase::OutputCXXDestructorDecl(d, dn);
     return;
   }
 
   unsigned int flags = 0;
-  if(d->isVirtual()) {
+  if (d->isVirtual()) {
     flags |= FH_Virtual;
   }
-  if(d->isPure()) {
+  if (d->isPure()) {
     flags |= FH_Pure;
   }
-  this->OutputFunctionHelper(d, dn, "Destructor",
-                             this->GetContextName(d), flags);
+  this->OutputFunctionHelper(d, dn, "Destructor", this->GetContextName(d),
+                             flags);
 }
 
 void ASTVisitor::OutputBuiltinType(clang::BuiltinType const* t,
@@ -1914,13 +2012,27 @@ void ASTVisitor::OutputBuiltinType(clang::BuiltinType const* t,
   // gccxml used different name variants than Clang for some types
   std::string name;
   switch (t->getKind()) {
-  case clang::BuiltinType::Short: name = "short int"; break;
-  case clang::BuiltinType::UShort: name = "short unsigned int"; break;
-  case clang::BuiltinType::Long: name = "long int"; break;
-  case clang::BuiltinType::ULong: name = "long unsigned int"; break;
-  case clang::BuiltinType::LongLong: name = "long long int"; break;
-  case clang::BuiltinType::ULongLong: name = "long long unsigned int"; break;
-  default: name = t->getName(this->PrintingPolicy).str(); break;
+    case clang::BuiltinType::Short:
+      name = "short int";
+      break;
+    case clang::BuiltinType::UShort:
+      name = "short unsigned int";
+      break;
+    case clang::BuiltinType::Long:
+      name = "long int";
+      break;
+    case clang::BuiltinType::ULong:
+      name = "long unsigned int";
+      break;
+    case clang::BuiltinType::LongLong:
+      name = "long long int";
+      break;
+    case clang::BuiltinType::ULongLong:
+      name = "long long unsigned int";
+      break;
+    default:
+      name = t->getName(this->PrintingPolicy).str();
+      break;
   };
   this->PrintNameAttribute(name);
   this->PrintABIAttributes(this->CTX.getTypeInfo(t));
@@ -1933,7 +2045,7 @@ void ASTVisitor::OutputConstantArrayType(clang::ConstantArrayType const* t,
 {
   this->OS << "  <ArrayType";
   this->PrintIdAttribute(dn);
-  this->OS << " min=\"0\" max=\"" << (t->getSize()-1) << "\"";
+  this->OS << " min=\"0\" max=\"" << (t->getSize() - 1) << "\"";
   this->PrintTypeAttribute(t->getElementType(), dn->Complete);
   this->OS << "/>\n";
 }
@@ -1966,7 +2078,7 @@ void ASTVisitor::OutputLValueReferenceType(clang::LValueReferenceType const* t,
 void ASTVisitor::OutputMemberPointerType(clang::MemberPointerType const* t,
                                          DumpNode const* dn)
 {
-  if(t->isMemberDataPointerType()) {
+  if (t->isMemberDataPointerType()) {
     this->OutputOffsetType(t->getPointeeType(), t->getClass(), dn);
   } else {
     this->OS << "  <PointerType";
@@ -2011,15 +2123,15 @@ void ASTVisitor::LookupStart(clang::DeclContext const* dc,
 
   clang::IdentifierTable& ids = CI.getPreprocessor().getIdentifierTable();
   auto const& result = dc->lookup(clang::DeclarationName(&ids.get(cur)));
-  if(pos == name.npos) {
-    for (clang::NamedDecl const* n: result) {
+  if (pos == name.npos) {
+    for (clang::NamedDecl const* n : result) {
       this->AddStartDecl(n);
     }
   } else {
-    std::string rest = name.substr(pos+2);
-    for (clang::NamedDecl const* n: result) {
+    std::string rest = name.substr(pos + 2);
+    for (clang::NamedDecl const* n : result) {
       if (clang::DeclContext const* idc =
-          clang::dyn_cast<clang::DeclContext const>(n)) {
+            clang::dyn_cast<clang::DeclContext const>(n)) {
         this->LookupStart(idc, rest);
       }
     }
@@ -2033,11 +2145,12 @@ void ASTVisitor::LookupStart(clang::DeclContext const* dc,
 void ASTVisitor::HandleTranslationUnit(clang::TranslationUnitDecl const* tu)
 {
   // Add the starting nodes for the dump.
-  if(!this->Opts.StartNames.empty()) {
+  if (!this->Opts.StartNames.empty()) {
     // Use the specified starting locations.
-    for(std::vector<std::string>::const_iterator
-          i = this->Opts.StartNames.begin(), e = this->Opts.StartNames.end();
-        i != e; ++i) {
+    for (std::vector<std::string>::const_iterator
+           i = this->Opts.StartNames.begin(),
+           e = this->Opts.StartNames.end();
+         i != e; ++i) {
       this->LookupStart(tu, *i);
     }
   } else {
@@ -2074,10 +2187,8 @@ void ASTVisitor::HandleTranslationUnit(clang::TranslationUnitDecl const* tu)
   /* clang-format on */
 }
 
-void outputXML(clang::CompilerInstance& ci,
-               clang::ASTContext& ctx,
-               llvm::raw_ostream& os,
-               Options const& opts)
+void outputXML(clang::CompilerInstance& ci, clang::ASTContext& ctx,
+               llvm::raw_ostream& os, Options const& opts)
 {
   ASTVisitor v(ci, ctx, os, opts);
   v.HandleTranslationUnit(ctx.getTranslationUnitDecl());