Replace FullComment member being visited with parameter

[aaron.ballman]

This is a really nice cleanup, thank you!

lib/AST/ASTDumper.cpp

114–115 ↗

(On Diff #175913)

Why not inherit from ConstCommentVisitor instead?

2684 ↗

(On Diff #175913)

If the argument isn't used in the function, can you drop the identifier for it from the parameter declaration? (Same elsewhere.)

[steveire]

Remove param

[steveire]

Remove &&

[steveire]

Rebase

[aaron.ballman]

LGTM!

cfe/trunk/lib/AST/ASTDumper.cpp

public:
     }
     ~ColorScope() {
       if (ShowColors)
         OS.resetColor();
     }
   };
 
   class ASTDumper
-      : public ConstDeclVisitor<ASTDumper>, public ConstStmtVisitor<ASTDumper>,
-        public ConstCommentVisitor<ASTDumper>, public TypeVisitor<ASTDumper> {
+      : public ConstDeclVisitor<ASTDumper>,
+        public ConstStmtVisitor<ASTDumper>,
+        public ConstCommentVisitor<ASTDumper, void, const FullComment *>,
+        public TypeVisitor<ASTDumper> {
+
     raw_ostream &OS;
     const CommandTraits *Traits;
     const SourceManager *SM;
 
     /// The policy to use for printing; can be defaulted.
     PrintingPolicy PrintPolicy;
 
     /// Pending[i] is an action to dump an entity at level i.
class ASTDumper
     /// Prefix for currently-being-dumped entity.
     std::string Prefix;
 
     /// Keep track of the last location we print out so that we can
     /// print out deltas from then on out.
     const char *LastLocFilename = "";
     unsigned LastLocLine = ~0U;
 
-    /// The \c FullComment parent of the comment being dumped.
-    const FullComment *FC = nullptr;
-
     const bool ShowColors;
 
     /// Dump a child of the current node.
     template<typename Fn> void dumpChild(Fn doDumpChild) {
       // If we're at the top level, there's nothing interesting to do; just
       // run the dumper.
       if (TopLevel) {
         TopLevel = false;
         doDumpChild();
         while (!Pending.empty()) {
           Pending.back()(true);
           Pending.pop_back();
         }
         Prefix.clear();
         OS << "\n";
         TopLevel = true;
         return;
       }
 
-      const FullComment *OrigFC = FC;
-      auto dumpWithIndent = [this, doDumpChild, OrigFC](bool isLastChild) {
+      auto dumpWithIndent = [this, doDumpChild](bool isLastChild) {
         // Print out the appropriate tree structure and work out the prefix for
         // children of this node. For instance:
         //
         //   A        Prefix = ""
         //   |-B      Prefix = "| "
         //   | `-C    Prefix = "|   "
         //   `-D      Prefix = "  "
         //     |-E    Prefix = "  | "
         //     `-F    Prefix = "    "
         //   G        Prefix = ""
         //
         // Note that the first level gets no prefix.
         {
           OS << '\n';
           ColorScope Color(OS, ShowColors, IndentColor);
           OS << Prefix << (isLastChild ? '`' : '|') << '-';
           this->Prefix.push_back(isLastChild ? ' ' : '|');
           this->Prefix.push_back(' ');
         }
 
         FirstChild = true;
         unsigned Depth = Pending.size();
 
-        FC = OrigFC;
         doDumpChild();
 
         // If any children are left, they're the last at their nesting level.
         // Dump those ones out now.
         while (Depth < Pending.size()) {
           Pending.back()(true);
           this->Pending.pop_back();
         }
public:
     void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node);
     void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node);
     void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node);
     void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node);
     void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node);
 
     // Comments.
     const char *getCommandName(unsigned CommandID);
-    void dumpComment(const Comment *C);
+    void dumpComment(const Comment *C, const FullComment *FC);
 
     // Inline comments.
-    void visitTextComment(const TextComment *C);
-    void visitInlineCommandComment(const InlineCommandComment *C);
-    void visitHTMLStartTagComment(const HTMLStartTagComment *C);
-    void visitHTMLEndTagComment(const HTMLEndTagComment *C);
+    void visitTextComment(const TextComment *C, const FullComment *FC);
+    void visitInlineCommandComment(const InlineCommandComment *C,
+                                   const FullComment *FC);
+    void visitHTMLStartTagComment(const HTMLStartTagComment *C,
+                                  const FullComment *FC);
+    void visitHTMLEndTagComment(const HTMLEndTagComment *C,
+                                const FullComment *FC);
 
     // Block comments.
-    void visitBlockCommandComment(const BlockCommandComment *C);
-    void visitParamCommandComment(const ParamCommandComment *C);
-    void visitTParamCommandComment(const TParamCommandComment *C);
-    void visitVerbatimBlockComment(const VerbatimBlockComment *C);
-    void visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C);
-    void visitVerbatimLineComment(const VerbatimLineComment *C);
+    void visitBlockCommandComment(const BlockCommandComment *C,
+                                  const FullComment *FC);
+    void visitParamCommandComment(const ParamCommandComment *C,
+                                  const FullComment *FC);
+    void visitTParamCommandComment(const TParamCommandComment *C,
+                                   const FullComment *FC);
+    void visitVerbatimBlockComment(const VerbatimBlockComment *C,
+                                   const FullComment *FC);
+    void visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C,
+                                       const FullComment *FC);
+    void visitVerbatimLineComment(const VerbatimLineComment *C,
+                                  const FullComment *FC);
   };
 }
 
 //===----------------------------------------------------------------------===//
 //  Utilities
 //===----------------------------------------------------------------------===//
 
 void ASTDumper::dumpPointer(const void *Ptr) {
const char *ASTDumper::getCommandName(unsigned CommandID) {
   if (Info)
     return Info->Name;
   return "<not a builtin command>";
 }
 
 void ASTDumper::dumpFullComment(const FullComment *C) {
   if (!C)
     return;
-
-  FC = C;
-  dumpComment(C);
-  FC = nullptr;
+  dumpComment(C, C);
 }
 
-void ASTDumper::dumpComment(const Comment *C) {
+void ASTDumper::dumpComment(const Comment *C, const FullComment *FC) {
   dumpChild([=] {
     if (!C) {
       ColorScope Color(OS, ShowColors, NullColor);
       OS << "<<<NULL>>>";
       return;
     }
 
     {
       ColorScope Color(OS, ShowColors, CommentColor);
       OS << C->getCommentKindName();
     }
     dumpPointer(C);
     dumpSourceRange(C->getSourceRange());
-    ConstCommentVisitor<ASTDumper>::visit(C);
+    ConstCommentVisitor<ASTDumper, void, const FullComment *>::visit(C, FC);
     for (Comment::child_iterator I = C->child_begin(), E = C->child_end();
          I != E; ++I)
-      dumpComment(*I);
+      dumpComment(*I, FC);
   });
 }
 
-void ASTDumper::visitTextComment(const TextComment *C) {
+void ASTDumper::visitTextComment(const TextComment *C, const FullComment *) {
   OS << " Text=\"" << C->getText() << "\"";
 }
 
-void ASTDumper::visitInlineCommandComment(const InlineCommandComment *C) {
+void ASTDumper::visitInlineCommandComment(const InlineCommandComment *C,
+                                          const FullComment *) {
   OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
   switch (C->getRenderKind()) {
   case InlineCommandComment::RenderNormal:
     OS << " RenderNormal";
     break;
   case InlineCommandComment::RenderBold:
     OS << " RenderBold";
     break;
   case InlineCommandComment::RenderMonospaced:
     OS << " RenderMonospaced";
     break;
   case InlineCommandComment::RenderEmphasized:
     OS << " RenderEmphasized";
     break;
   }
 
   for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
     OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
 }
 
-void ASTDumper::visitHTMLStartTagComment(const HTMLStartTagComment *C) {
+void ASTDumper::visitHTMLStartTagComment(const HTMLStartTagComment *C,
+                                         const FullComment *) {
   OS << " Name=\"" << C->getTagName() << "\"";
   if (C->getNumAttrs() != 0) {
     OS << " Attrs: ";
     for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) {
       const HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
       OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\"";
     }
   }
   if (C->isSelfClosing())
     OS << " SelfClosing";
 }
 
-void ASTDumper::visitHTMLEndTagComment(const HTMLEndTagComment *C) {
+void ASTDumper::visitHTMLEndTagComment(const HTMLEndTagComment *C,
+                                       const FullComment *) {
   OS << " Name=\"" << C->getTagName() << "\"";
 }
 
-void ASTDumper::visitBlockCommandComment(const BlockCommandComment *C) {
+void ASTDumper::visitBlockCommandComment(const BlockCommandComment *C,
+                                         const FullComment *) {
   OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
   for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
     OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
 }
 
-void ASTDumper::visitParamCommandComment(const ParamCommandComment *C) {
+void ASTDumper::visitParamCommandComment(const ParamCommandComment *C,
+                                         const FullComment *FC) {
   OS << " " << ParamCommandComment::getDirectionAsString(C->getDirection());
 
   if (C->isDirectionExplicit())
     OS << " explicitly";
   else
     OS << " implicitly";
 
   if (C->hasParamName()) {
     if (C->isParamIndexValid())
       OS << " Param=\"" << C->getParamName(FC) << "\"";
     else
       OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
   }
 
   if (C->isParamIndexValid() && !C->isVarArgParam())
     OS << " ParamIndex=" << C->getParamIndex();
 }
 
-void ASTDumper::visitTParamCommandComment(const TParamCommandComment *C) {
+void ASTDumper::visitTParamCommandComment(const TParamCommandComment *C,
+                                          const FullComment *FC) {
   if (C->hasParamName()) {
     if (C->isPositionValid())
       OS << " Param=\"" << C->getParamName(FC) << "\"";
     else
       OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
   }
 
   if (C->isPositionValid()) {
     OS << " Position=<";
     for (unsigned i = 0, e = C->getDepth(); i != e; ++i) {
       OS << C->getIndex(i);
       if (i != e - 1)
         OS << ", ";
     }
     OS << ">";
   }
 }
 
-void ASTDumper::visitVerbatimBlockComment(const VerbatimBlockComment *C) {
+void ASTDumper::visitVerbatimBlockComment(const VerbatimBlockComment *C,
+                                          const FullComment *) {
   OS << " Name=\"" << getCommandName(C->getCommandID()) << "\""
         " CloseName=\"" << C->getCloseName() << "\"";
 }
 
-void ASTDumper::visitVerbatimBlockLineComment(
-    const VerbatimBlockLineComment *C) {
+void ASTDumper::visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C,
+                                              const FullComment *) {
   OS << " Text=\"" << C->getText() << "\"";
 }
 
-void ASTDumper::visitVerbatimLineComment(const VerbatimLineComment *C) {
+void ASTDumper::visitVerbatimLineComment(const VerbatimLineComment *C,
+                                         const FullComment *) {
   OS << " Text=\"" << C->getText() << "\"";
 }
 
 //===----------------------------------------------------------------------===//
 // Type method implementations
 //===----------------------------------------------------------------------===//
 
 void QualType::dump(const char *msg) const {