[clang][NFC] Refactor InlineCommandComment::RenderKind

This patch converts `InlineCommandComment::RenderKind` to a scoped enum at namespace scope, making it eligible for forward declaring. This is useful for e.g. annotating bit-fields with `preferred_type`.

Author: Endilll

clang/include/clang/AST/Comment.h

@@ -297,31 +297,24 @@ class TextComment : public InlineContentComment {
   bool isWhitespaceNoCache() const;
 };
 
+/// The most appropriate rendering mode for this command, chosen on command
+/// semantics in Doxygen.
+enum InlineCommandRenderKind { Normal, Bold, Monospaced, Emphasized, Anchor };
+
 /// A command with word-like arguments that is considered inline content.
 class InlineCommandComment : public InlineContentComment {
-public:
-  /// The most appropriate rendering mode for this command, chosen on command
-  /// semantics in Doxygen.
-  enum RenderKind {
-    RenderNormal,
-    RenderBold,
-    RenderMonospaced,
-    RenderEmphasized,
-    RenderAnchor
-  };
-
 protected:
   /// Command arguments.
   ArrayRef<Argument> Args;
 
 public:
   InlineCommandComment(SourceLocation LocBegin, SourceLocation LocEnd,
-                       unsigned CommandID, RenderKind RK,
+                       unsigned CommandID, InlineCommandRenderKind RK,
                        ArrayRef<Argument> Args)
       : InlineContentComment(CommentKind::InlineCommandComment, LocBegin,
                              LocEnd),
         Args(Args) {
-    InlineCommandCommentBits.RenderKind = RK;
+    InlineCommandCommentBits.RenderKind = llvm::to_underlying(RK);
     InlineCommandCommentBits.CommandID = CommandID;
   }
 
@@ -345,8 +338,9 @@ class InlineCommandComment : public InlineContentComment {
     return SourceRange(getBeginLoc().getLocWithOffset(-1), getEndLoc());
   }
 
-  RenderKind getRenderKind() const {
-    return static_cast<RenderKind>(InlineCommandCommentBits.RenderKind);
+  InlineCommandRenderKind getRenderKind() const {
+    return static_cast<InlineCommandRenderKind>(
+        InlineCommandCommentBits.RenderKind);
   }
 
   unsigned getNumArgs() const {

clang/include/clang/AST/CommentSema.h

@@ -244,8 +244,7 @@ class Sema {
                               StringRef Typo,
                               const TemplateParameterList *TemplateParameters);
 
-  InlineCommandComment::RenderKind
-  getInlineCommandRenderKind(StringRef Name) const;
+  InlineCommandRenderKind getInlineCommandRenderKind(StringRef Name) const;
 };
 
 } // end namespace comments

clang/lib/AST/CommentSema.cpp

@@ -380,9 +380,7 @@ InlineContentComment *Sema::actOnUnknownCommand(SourceLocation LocBegin,
                                                 unsigned CommandID) {
   ArrayRef<InlineCommandComment::Argument> Args;
   return new (Allocator) InlineCommandComment(
-                                  LocBegin, LocEnd, CommandID,
-                                  InlineCommandComment::RenderNormal,
-                                  Args);
+      LocBegin, LocEnd, CommandID, InlineCommandRenderKind::Normal, Args);
 }
 
 TextComment *Sema::actOnText(SourceLocation LocBegin,
@@ -1108,16 +1106,15 @@ StringRef Sema::correctTypoInTParamReference(
   return StringRef();
 }
 
-InlineCommandComment::RenderKind
-Sema::getInlineCommandRenderKind(StringRef Name) const {
+InlineCommandRenderKind Sema::getInlineCommandRenderKind(StringRef Name) const {
   assert(Traits.getCommandInfo(Name)->IsInlineCommand);
 
-  return llvm::StringSwitch<InlineCommandComment::RenderKind>(Name)
-      .Case("b", InlineCommandComment::RenderBold)
-      .Cases("c", "p", InlineCommandComment::RenderMonospaced)
-      .Cases("a", "e", "em", InlineCommandComment::RenderEmphasized)
-      .Case("anchor", InlineCommandComment::RenderAnchor)
-      .Default(InlineCommandComment::RenderNormal);
+  return llvm::StringSwitch<InlineCommandRenderKind>(Name)
+      .Case("b", InlineCommandRenderKind::Bold)
+      .Cases("c", "p", InlineCommandRenderKind::Monospaced)
+      .Cases("a", "e", "em", InlineCommandRenderKind::Emphasized)
+      .Case("anchor", InlineCommandRenderKind::Anchor)
+      .Default(InlineCommandRenderKind::Normal);
 }
 
 } // end namespace comments

clang/lib/AST/JSONNodeDumper.cpp

@@ -1680,19 +1680,19 @@ void JSONNodeDumper::visitInlineCommandComment(
   JOS.attribute("name", getCommentCommandName(C->getCommandID()));
 
   switch (C->getRenderKind()) {
-  case comments::InlineCommandComment::RenderNormal:
+  case comments::InlineCommandRenderKind::Normal:
     JOS.attribute("renderKind", "normal");
     break;
-  case comments::InlineCommandComment::RenderBold:
+  case comments::InlineCommandRenderKind::Bold:
     JOS.attribute("renderKind", "bold");
     break;
-  case comments::InlineCommandComment::RenderEmphasized:
+  case comments::InlineCommandRenderKind::Emphasized:
     JOS.attribute("renderKind", "emphasized");
     break;
-  case comments::InlineCommandComment::RenderMonospaced:
+  case comments::InlineCommandRenderKind::Monospaced:
     JOS.attribute("renderKind", "monospaced");
     break;
-  case comments::InlineCommandComment::RenderAnchor:
+  case comments::InlineCommandRenderKind::Anchor:
     JOS.attribute("renderKind", "anchor");
     break;
   }

clang/lib/AST/TextNodeDumper.cpp

@@ -862,19 +862,19 @@ void TextNodeDumper::visitInlineCommandComment(
     const comments::InlineCommandComment *C, const comments::FullComment *) {
   OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
   switch (C->getRenderKind()) {
-  case comments::InlineCommandComment::RenderNormal:
+  case comments::InlineCommandRenderKind::Normal:
     OS << " RenderNormal";
     break;
-  case comments::InlineCommandComment::RenderBold:
+  case comments::InlineCommandRenderKind::Bold:
     OS << " RenderBold";
     break;
-  case comments::InlineCommandComment::RenderMonospaced:
+  case comments::InlineCommandRenderKind::Monospaced:
     OS << " RenderMonospaced";
     break;
-  case comments::InlineCommandComment::RenderEmphasized:
+  case comments::InlineCommandRenderKind::Emphasized:
     OS << " RenderEmphasized";
     break;
-  case comments::InlineCommandComment::RenderAnchor:
+  case comments::InlineCommandRenderKind::Anchor:
     OS << " RenderAnchor";
     break;
   }

clang/lib/Index/CommentToXML.cpp

@@ -274,32 +274,32 @@ void CommentASTToHTMLConverter::visitInlineCommandComment(
     return;
 
   switch (C->getRenderKind()) {
-  case InlineCommandComment::RenderNormal:
+  case InlineCommandRenderKind::Normal:
     for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i) {
       appendToResultWithHTMLEscaping(C->getArgText(i));
       Result << " ";
     }
     return;
 
-  case InlineCommandComment::RenderBold:
+  case InlineCommandRenderKind::Bold:
     assert(C->getNumArgs() == 1);
     Result << "<b>";
     appendToResultWithHTMLEscaping(Arg0);
     Result << "</b>";
     return;
-  case InlineCommandComment::RenderMonospaced:
+  case InlineCommandRenderKind::Monospaced:
     assert(C->getNumArgs() == 1);
     Result << "<tt>";
     appendToResultWithHTMLEscaping(Arg0);
     Result<< "</tt>";
     return;
-  case InlineCommandComment::RenderEmphasized:
+  case InlineCommandRenderKind::Emphasized:
     assert(C->getNumArgs() == 1);
     Result << "<em>";
     appendToResultWithHTMLEscaping(Arg0);
     Result << "</em>";
     return;
-  case InlineCommandComment::RenderAnchor:
+  case InlineCommandRenderKind::Anchor:
     assert(C->getNumArgs() == 1);
     Result << "<span id=\"" << Arg0 << "\"></span>";
     return;
@@ -623,31 +623,31 @@ void CommentASTToXMLConverter::visitInlineCommandComment(
     return;
 
   switch (C->getRenderKind()) {
-  case InlineCommandComment::RenderNormal:
+  case InlineCommandRenderKind::Normal:
     for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i) {
       appendToResultWithXMLEscaping(C->getArgText(i));
       Result << " ";
     }
     return;
-  case InlineCommandComment::RenderBold:
+  case InlineCommandRenderKind::Bold:
     assert(C->getNumArgs() == 1);
     Result << "<bold>";
     appendToResultWithXMLEscaping(Arg0);
     Result << "</bold>";
     return;
-  case InlineCommandComment::RenderMonospaced:
+  case InlineCommandRenderKind::Monospaced:
     assert(C->getNumArgs() == 1);
     Result << "<monospaced>";
     appendToResultWithXMLEscaping(Arg0);
     Result << "</monospaced>";
     return;
-  case InlineCommandComment::RenderEmphasized:
+  case InlineCommandRenderKind::Emphasized:
     assert(C->getNumArgs() == 1);
     Result << "<emphasized>";
     appendToResultWithXMLEscaping(Arg0);
     Result << "</emphasized>";
     return;
-  case InlineCommandComment::RenderAnchor:
+  case InlineCommandRenderKind::Anchor:
     assert(C->getNumArgs() == 1);
     Result << "<anchor id=\"" << Arg0 << "\"></anchor>";
     return;

clang/tools/libclang/CXComment.cpp

@@ -148,19 +148,19 @@ clang_InlineCommandComment_getRenderKind(CXComment CXC) {
     return CXCommentInlineCommandRenderKind_Normal;
 
   switch (ICC->getRenderKind()) {
-  case InlineCommandComment::RenderNormal:
+  case InlineCommandRenderKind::Normal:
     return CXCommentInlineCommandRenderKind_Normal;
 
-  case InlineCommandComment::RenderBold:
+  case InlineCommandRenderKind::Bold:
     return CXCommentInlineCommandRenderKind_Bold;
 
-  case InlineCommandComment::RenderMonospaced:
+  case InlineCommandRenderKind::Monospaced:
     return CXCommentInlineCommandRenderKind_Monospaced;
 
-  case InlineCommandComment::RenderEmphasized:
+  case InlineCommandRenderKind::Emphasized:
     return CXCommentInlineCommandRenderKind_Emphasized;
 
-  case InlineCommandComment::RenderAnchor:
+  case InlineCommandRenderKind::Anchor:
     return CXCommentInlineCommandRenderKind_Anchor;
   }
   llvm_unreachable("unknown InlineCommandComment::RenderKind");