Comment Sema: Use Name from CommandInfo for HeaderDoc diagnostics (NFC)

[aaronpuchert]

Summary

We don't have to figure out the name, we can just fetch it from the
metadata table. Also there is no reason to %select over the names since
they're not natural language but keywords.

Subsequently we can focus on the actual logic and merge some branches
together. Unhandled cases are now marked unreachable, but this shouldn't
have any effect as of now. (We handle all existing commands.)

clang/include/clang/AST/CommentCommands.td

class VerbatimLineCommand<string name> : Command<name> {
   let IsVerbatimLineCommand = 1;
 }
 
 class DeclarationVerbatimLineCommand<string name> :
       VerbatimLineCommand<name> {
   let IsDeclarationCommand = 1;
 }
 
+// Make sure these are handled in comments::Sema::checkFunctionDeclVerbatimLine.
 class FunctionDeclarationVerbatimLineCommand<string name> :
       DeclarationVerbatimLineCommand<name> {
   let IsFunctionDeclarationCommand = 1;
 }
 
+// Make sure these are handled in comments::Sema::checkContainerDeclVerbatimLine.
 class RecordLikeDeclarationVerbatimLineCommand<string name> :
       DeclarationVerbatimLineCommand<name> {
   let IsRecordLikeDeclarationCommand = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // InlineCommand
 //===----------------------------------------------------------------------===//

clang/include/clang/Basic/DiagnosticCommentKinds.td

def warn_doc_param_spaces_in_direction : Warning<
   InGroup<DocumentationPedantic>, DefaultIgnore;
 
 def warn_doc_param_not_attached_to_a_function_decl : Warning<
   "'%select{\\|@}0param' command used in a comment that is not attached to "
   "a function declaration">,
   InGroup<Documentation>, DefaultIgnore;
 
 def warn_doc_function_method_decl_mismatch : Warning<
-  "'%select{\\|@}0%select{function|functiongroup|method|methodgroup|callback}1' "
-  "command should be used in a comment attached to "
-  "%select{a function|a function|an Objective-C method|an Objective-C method|"
-  "a pointer to function}2 declaration">,
+  "'%select{\\|@}0%1' command should be used in a comment attached to "
+  "%select{a function|an Objective-C method|a pointer to function}2 declaration">,
   InGroup<Documentation>, DefaultIgnore;
 
 def warn_doc_api_container_decl_mismatch : Warning<
-  "'%select{\\|@}0%select{class|interface|protocol|struct|union}1' "
-  "command should not be used in a comment attached to a "
-  "non-%select{class|interface|protocol|struct|union}2 declaration">,
+  "'%select{\\|@}0%1' command should not be used in a comment attached to a "
+  "non-%1 declaration">,
   InGroup<Documentation>, DefaultIgnore;
 
 def warn_doc_container_decl_mismatch : Warning<
-  "'%select{\\|@}0%select{classdesign|coclass|dependency|helper"
-  "|helperclass|helps|instancesize|ownership|performance|security|superclass}1' "
-  "command should not be used in a comment attached to a non-container declaration">,
+  "'%select{\\|@}0%1' command should not be used in a comment attached to a "
+  "non-container declaration">,
   InGroup<Documentation>, DefaultIgnore;
 
 def warn_doc_param_duplicate : Warning<
   "parameter '%0' is already documented">,
   InGroup<Documentation>, DefaultIgnore;
 
 def note_doc_param_previous : Note<
   "previous documentation">;

clang/lib/AST/CommentSema.cpp

Diag(Command->getLocation(),
       << Command->getCommandNameRange(Traits);
 
   return Command;
 }
 
 void Sema::checkFunctionDeclVerbatimLine(const BlockCommandComment *Comment) {
   unsigned DiagSelect;
   switch (Comment->getCommandID()) {
-    case CommandTraits::KCI_function:
-      DiagSelect = (!isAnyFunctionDecl() && !isFunctionTemplateDecl())? 1 : 0;
-      break;
-    case CommandTraits::KCI_functiongroup:
-      DiagSelect = (!isAnyFunctionDecl() && !isFunctionTemplateDecl())? 2 : 0;
-      break;
-    case CommandTraits::KCI_method:
-      DiagSelect = !isObjCMethodDecl() ? 3 : 0;
-      break;
-    case CommandTraits::KCI_methodgroup:
-      DiagSelect = !isObjCMethodDecl() ? 4 : 0;
-      break;
-    case CommandTraits::KCI_callback:
-      DiagSelect = !isFunctionPointerVarDecl() ? 5 : 0;
-      break;
-    default:
-      DiagSelect = 0;
-      break;
+    if (isAnyFunctionDecl() || isFunctionTemplateDecl())
+      return;
+    DiagSelect = 0;
+    if (isObjCMethodDecl())
+      return;
+    DiagSelect = 1;
+    if (isFunctionPointerVarDecl())
+      return;
+    DiagSelect = 2;
+    llvm_unreachable("Unhandled command with IsFunctionDeclarationCommand");
   }
-  if (DiagSelect)
-    Diag(Comment->getLocation(), diag::warn_doc_function_method_decl_mismatch)
       << Comment->getCommandMarker()
-    << (DiagSelect-1) << (DiagSelect-1)
+      << Traits.getCommandInfo(Comment->getCommandID())->Name << DiagSelect
       << Comment->getSourceRange();
 }
 
 void Sema::checkContainerDeclVerbatimLine(const BlockCommandComment *Comment) {
-  unsigned DiagSelect;
   switch (Comment->getCommandID()) {
     case CommandTraits::KCI_class:
-      DiagSelect =
-          (!isClassOrStructOrTagTypedefDecl() && !isClassTemplateDecl()) ? 1
-                                                                         : 0;
+      if (isClassOrStructOrTagTypedefDecl() || isClassTemplateDecl())
+        return;
       // Allow @class command on @interface declarations.
       // FIXME. Currently, \class and @class are indistinguishable. So,
       // \class is also allowed on an @interface declaration
-      if (DiagSelect && Comment->getCommandMarker() && isObjCInterfaceDecl())
-        DiagSelect = 0;
+      if (Comment->getCommandMarker() && isObjCInterfaceDecl())
+        return;
       break;
     case CommandTraits::KCI_interface:
-      DiagSelect = !isObjCInterfaceDecl() ? 2 : 0;
+      if (isObjCInterfaceDecl())
+        return;
       break;
     case CommandTraits::KCI_protocol:
-      DiagSelect = !isObjCProtocolDecl() ? 3 : 0;
+      if (isObjCProtocolDecl())
+        return;
       break;
     case CommandTraits::KCI_struct:
-      DiagSelect = !isClassOrStructOrTagTypedefDecl() ? 4 : 0;
+      if (isClassOrStructOrTagTypedefDecl())
+        return;
       break;
     case CommandTraits::KCI_union:
-      DiagSelect = !isUnionDecl() ? 5 : 0;
+      if (isUnionDecl())
+        return;
       break;
     default:
-      DiagSelect = 0;
-      break;
+      llvm_unreachable("Unhandled command with IsRecordLikeDeclarationCommand");
   }
-  if (DiagSelect)
-    Diag(Comment->getLocation(), diag::warn_doc_api_container_decl_mismatch)
       << Comment->getCommandMarker()
-    << (DiagSelect-1) << (DiagSelect-1)
+      << Traits.getCommandInfo(Comment->getCommandID())->Name
       << Comment->getSourceRange();
 }
 
 void Sema::checkContainerDecl(const BlockCommandComment *Comment) {
   if (isRecordLikeDecl())
     return;
-  unsigned DiagSelect;
-  switch (Comment->getCommandID()) {
-    case CommandTraits::KCI_classdesign:
-      DiagSelect = 1;
-      break;
-    case CommandTraits::KCI_coclass:
-      DiagSelect = 2;
-      break;
-    case CommandTraits::KCI_dependency:
-      DiagSelect = 3;
-      break;
-    case CommandTraits::KCI_helper:
-      DiagSelect = 4;
-      break;
-    case CommandTraits::KCI_helperclass:
-      DiagSelect = 5;
-      break;
-    case CommandTraits::KCI_helps:
-      DiagSelect = 6;
-      break;
-    case CommandTraits::KCI_instancesize:
-      DiagSelect = 7;
-      break;
-    case CommandTraits::KCI_ownership:
-      DiagSelect = 8;
-      break;
-    case CommandTraits::KCI_performance:
-      DiagSelect = 9;
-      break;
-    case CommandTraits::KCI_security:
-      DiagSelect = 10;
-      break;
-    case CommandTraits::KCI_superclass:
-      DiagSelect = 11;
-      break;
-    default:
-      DiagSelect = 0;
-      break;
-  }
-  if (DiagSelect)
-    Diag(Comment->getLocation(), diag::warn_doc_container_decl_mismatch)
       << Comment->getCommandMarker()
-    << (DiagSelect-1)
+      << Traits.getCommandInfo(Comment->getCommandID())->Name
       << Comment->getSourceRange();
 }
 
 /// Turn a string into the corresponding PassDirection or -1 if it's not
 /// valid.
 static int getParamPassDirection(StringRef Arg) {
   return llvm::StringSwitch<int>(Arg)
       .Case("[in]", ParamCommandComment::In)
       .Case("[out]", ParamCommandComment::Out)