Comment parsing: Allow inline commands to have 0 or more than 1 argument

[aaronpuchert]

Summary

That's required to support \n, but can also used for other commands.
The argument parsing is basically duplicated from block commands, but we
can't easily factor that out as they have a different argument data
type.

This should fix #55319.

[aaronpuchert]

clang/include/clang/AST/Comment.h

303

Removing that allows me to build an array without initializing all members right away. Alternative would be to add a default constructor here.

clang/include/clang/Basic/DiagnosticCommentKinds.td

159

If you find that %plural too fancy, a plain %2 should also do.

clang/lib/AST/CommentParser.cpp

291–304

This is basically what I'm duplicating. As it happens, the two Argument structures are structurally the same, so we could unify them and factor out this code. I'd probably do that in a separate change though (prior to this or as follow-up).

clang/test/Headers/x86-intrinsics-headers-clean.cpp

4

@RKSimon, according to https://github.com/llvm/llvm-project/issues/35297 you mostly wanted -pedantic, but I took the liberty of enabling both. They're currently coupled (similar to https://github.com/llvm/llvm-project/issues/19442).

[gribozavr2]

clang/include/clang/AST/CommentCommands.td

94

Could you add a test that shows that the text after \n is not treated as the argument?

You could verify the comment AST like here: llvm-project/clang/test/AST/ast-dump-comment.cpp

[RKSimon]

Thanks @aaronpuchert !

[aaronpuchert]

clang/include/clang/AST/CommentCommands.td

94

That's a good idea, I'll do that.

[aaronpuchert]

Unify Argument types and parsing. Add AST test. Simplify TableGen.

[thakis]

Hello, this broke building on mac:

• http://45.33.8.238/macm1/35247/step_4.txtp
• https://green.lab.llvm.org/green/job/clang-stage1-RA/

Please take a look, and revert for now if it takes a while to fix.

(Here's the error:

In file included from ../../clang/lib/AST/CommentParser.cpp:9:
In file included from ../../clang/include/clang/AST/CommentParser.h:16:
In file included from ../../clang/include/clang/AST/Comment.h:17:
In file included from ../../clang/include/clang/AST/DeclObjC.h:16:
In file included from ../../clang/include/clang/AST/Decl.h:19:
In file included from ../../clang/include/clang/AST/DeclBase.h:18:
In file included from ../../clang/include/clang/AST/DeclarationName.h:16:
In file included from ../../clang/include/clang/AST/Type.h:21:
In file included from ../../clang/include/clang/AST/NestedNameSpecifier.h:18:
../../clang/include/clang/Basic/Diagnostic.h:1353:8: error: use of overloaded operator '<<' is ambiguous (with operand types 'const clang::StreamingDiagnostic' and 'typename remove_reference<unsigned long &>::type' (aka 'unsigned long'))
    DB << std::move(V);
    ~~ ^  ~~~~~~~~~~~~
../../clang/lib/AST/CommentParser.cpp:417:57: note: in instantiation of function template specialization 'clang::DiagnosticBuilder::operator<<<unsigned long, void>' requested here
        << CommandTok.is(tok::at_command) << Info->Name << Args.size()
                                                        ^
../../clang/include/clang/Basic/Diagnostic.h:1400:35: note: candidate function
inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                  ^
../../clang/include/clang/Basic/Diagnostic.h:1406:35: note: candidate function
inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                  ^
../../clang/include/clang/Basic/Diagnostic.h:1422:35: note: candidate function
inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                  ^
../../clang/include/clang/Basic/Diagnostic.h:1428:35: note: candidate function
inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                  ^
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(int, unsigned long)
    DB << std::move(V);
       ^
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(int, int)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(int, long)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(int, long long)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(int, __int128)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(int, unsigned int)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(int, unsigned long long)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(int, unsigned __int128)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(long, unsigned long)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(long long, unsigned long)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(__int128, unsigned long)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(unsigned int, unsigned long)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(unsigned long, unsigned long)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(unsigned long long, unsigned long)
../../clang/include/clang/Basic/Diagnostic.h:1353:8: note: built-in candidate operator<<(unsigned __int128, unsigned long)

)

[aaronpuchert]

Hmm, didn't see this on Linux. I'll try to disambiguate.

[aaronpuchert]

So we have overloads

inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, int I);
inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, int64_t I);
inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, unsigned I);
inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, uint64_t I);

And it appears that unsigned long does not have a clear favorite here. Is that because long is 32-bit like on Windows, but at the same time it's not the same as unsigned which is also 32-bit? Could we resolve this somehow so that we don't have the next person writing inconspicuous code to run into this?

Perhaps we should overload on (u)int32_t instead int/unsigned?

[thakis]

https://github.com/llvm/llvm-project/commit/25862f53cce966cef2957825095861dec631d4f1 fixed the build, thanks!

No opinion off the top of my head on changing the signature. Might be a good idea, maybe?

[aaronpuchert]

In D125429#3511648, @aaronpuchert wrote:

And it appears that unsigned long does not have a clear favorite here.

Found it on StackOverflow: https://stackoverflow.com/questions/11603818/why-is-there-ambiguity-between-uint32-t-and-uint64-t-when-using-size-t-on-mac-os.

Is that because long is 32-bit like on Windows, but at the same time it's not the same as unsigned which is also 32-bit?

No. Mac is LP64, but uses long long for (u)int64_t.

Perhaps we should overload on (u)int32_t instead int/unsigned?

Hence this doesn't solve it. I'm thinking that perhaps we should overload on int, long, long long. Seems silly, but C++ defines them as different types. Proposed this in D125580.

[aaronpuchert]

In D125429#3512642, @aaronpuchert wrote:

Proposed this in D125580.

Landed this two days ago and no one complained about it so far, so let's hope that solved it.

clang/include/clang/AST/Comment.h

 #define COMMENT_RANGE(BASE, FIRST, LAST) \
     First##BASE##Constant=FIRST##Kind, Last##BASE##Constant=LAST##Kind,
 #define LAST_COMMENT_RANGE(BASE, FIRST, LAST) \
     First##BASE##Constant=FIRST##Kind, Last##BASE##Constant=LAST##Kind
 #define ABSTRACT_COMMENT(COMMENT)
 #include "clang/AST/CommentNodes.inc"
   };
 
+  struct Argument {
+    SourceRange Range;
+    StringRef Text;
+  };
+
   Comment(CommentKind K,
           SourceLocation LocBegin,
           SourceLocation LocEnd) :
       Loc(LocBegin), Range(SourceRange(LocBegin, LocEnd)) {
     CommentBits.Kind = K;
   }
 
   CommentKind getCommentKind() const {

 
 private:
   bool isWhitespaceNoCache() const;
 };
 
 /// A command with word-like arguments that is considered inline content.
 class InlineCommandComment : public InlineContentComment {
 public:
-  struct Argument {
-    SourceRange Range;
-    StringRef Text;
-
-    Argument(SourceRange Range, StringRef Text) : Range(Range), Text(Text) { }
-  };
-
   /// The most appropriate rendering mode for this command, chosen on command
   /// semantics in Doxygen.
   enum RenderKind {
     RenderNormal,
     RenderBold,
     RenderMonospaced,
     RenderEmphasized,
     RenderAnchor

 private:
   bool isWhitespaceNoCache() const;
 };
 
 /// A command that has zero or more word-like arguments (number of word-like
 /// arguments depends on command name) and a paragraph as an argument
 /// (e. g., \\brief).
 class BlockCommandComment : public BlockContentComment {
-public:
-  struct Argument {
-    SourceRange Range;
-    StringRef Text;
-
-    Argument() { }
-    Argument(SourceRange Range, StringRef Text) : Range(Range), Text(Text) { }
-  };
-
 protected:
   /// Word-like arguments.
   ArrayRef<Argument> Args;
 
   /// Paragraph argument.
   ParagraphComment *Paragraph;
 
   BlockCommandComment(CommentKind K,

clang/include/clang/AST/CommentCommands.td

class Command<string name> {
   bit IsVerbatimLineCommand = 0;
   bit IsDeclarationCommand = 0;
   bit IsFunctionDeclarationCommand = 0;
   bit IsRecordLikeDetailCommand = 0;
   bit IsRecordLikeDeclarationCommand = 0;
 }
 
 class InlineCommand<string name> : Command<name> {
+  let NumArgs = 1;
   let IsInlineCommand = 1;
 }
 
 class BlockCommand<string name> : Command<name> {
   let IsBlockCommand = 1;
 }
 
 class RecordLikeDetailCommand<string name> : BlockCommand<name> {

 // InlineCommand
 //===----------------------------------------------------------------------===//
 
 def B      : InlineCommand<"b">;
 def C      : InlineCommand<"c">;
 def P      : InlineCommand<"p">;
 def A      : InlineCommand<"a">;
 def E      : InlineCommand<"e">;
+def N      : InlineCommand<"n"> { let NumArgs = 0; }
 def Em     : InlineCommand<"em">;
 def Emoji  : InlineCommand<"emoji">;
 
 def Anchor  : InlineCommand<"anchor">;
 def Ref     : InlineCommand<"ref">;
 def RefItem : InlineCommand<"refitem">;
 def Cite    : InlineCommand<"cite">;
 
 def CopyBrief   : InlineCommand<"copybrief">;
 def CopyDetails : InlineCommand<"copydetails">;
 def CopyDoc     : InlineCommand<"copydoc">;
 

clang/include/clang/AST/CommentParser.h

public:
   /// Parse arguments for \\param command.
   void parseParamCommandArgs(ParamCommandComment *PC,
                              TextTokenRetokenizer &Retokenizer);
 
   /// Parse arguments for \\tparam command.
   void parseTParamCommandArgs(TParamCommandComment *TPC,
                               TextTokenRetokenizer &Retokenizer);
 
-  void parseBlockCommandArgs(BlockCommandComment *BC,
-                             TextTokenRetokenizer &Retokenizer,
-                             unsigned NumArgs);
+  ArrayRef<Comment::Argument>
+  parseCommandArgs(TextTokenRetokenizer &Retokenizer, unsigned NumArgs);
 
   BlockCommandComment *parseBlockCommand();
   InlineCommandComment *parseInlineCommand();
 
   HTMLStartTagComment *parseHTMLStartTag();
   HTMLEndTagComment *parseHTMLEndTag();
 
   BlockContentComment *parseParagraphOrBlockCommand();

clang/include/clang/AST/CommentSema.h

void actOnTParamCommandParamNameArg(TParamCommandComment *Command,
                                       SourceLocation ArgLocEnd,
                                       StringRef Arg);
 
   void actOnTParamCommandFinish(TParamCommandComment *Command,
                                 ParagraphComment *Paragraph);
 
   InlineCommandComment *actOnInlineCommand(SourceLocation CommandLocBegin,
                                            SourceLocation CommandLocEnd,
-                                           unsigned CommandID);
-
-  InlineCommandComment *actOnInlineCommand(SourceLocation CommandLocBegin,
-                                           SourceLocation CommandLocEnd,
                                            unsigned CommandID,
-                                           SourceLocation ArgLocBegin,
-                                           SourceLocation ArgLocEnd,
-                                           StringRef Arg);
+                                           ArrayRef<Comment::Argument> Args);
 
   InlineContentComment *actOnUnknownCommand(SourceLocation LocBegin,
                                             SourceLocation LocEnd,
                                             StringRef CommandName);
 
   InlineContentComment *actOnUnknownCommand(SourceLocation LocBegin,
                                             SourceLocation LocEnd,
                                             unsigned CommandID);

clang/include/clang/Basic/DiagnosticCommentKinds.td

def warn_doc_deprecated_not_sync : Warning<
   "not have a deprecation attribute">,
   InGroup<DocumentationDeprecatedSync>, DefaultIgnore;
 
 def note_add_deprecation_attr : Note<
   "add a deprecation attribute to the declaration to silence this warning">;
 
 // inline contents commands
 
-def warn_doc_inline_contents_no_argument : Warning<
-  "'%select{\\|@}0%1' command does not have a valid word argument">,
+def warn_doc_inline_command_not_enough_arguments : Warning<
+  "'%select{\\|@}0%1' command has %plural{0:no|:%2}2 word argument%s2, expected %3">,
   InGroup<Documentation>, DefaultIgnore;
 
 // verbatim block commands
 
 def warn_verbatim_block_end_without_start : Warning<
   "'%select{\\|@}0%1' command does not terminate a verbatim text block">,
   InGroup<Documentation>, DefaultIgnore;
 

clang/lib/AST/CommentParser.cpp

void Parser::parseTParamCommandArgs(TParamCommandComment *TPC,
                                     TextTokenRetokenizer &Retokenizer) {
   Token Arg;
   if (Retokenizer.lexWord(Arg))
     S.actOnTParamCommandParamNameArg(TPC,
                                      Arg.getLocation(),
                                      Arg.getEndLocation(),
                                      Arg.getText());
 }
 
-void Parser::parseBlockCommandArgs(BlockCommandComment *BC,
-                                   TextTokenRetokenizer &Retokenizer,
-                                   unsigned NumArgs) {
-  typedef BlockCommandComment::Argument Argument;
-  Argument *Args =
-      new (Allocator.Allocate<Argument>(NumArgs)) Argument[NumArgs];
+ArrayRef<Comment::Argument>
+Parser::parseCommandArgs(TextTokenRetokenizer &Retokenizer, unsigned NumArgs) {
+  auto *Args = new (Allocator.Allocate<Comment::Argument>(NumArgs))
+      Comment::Argument[NumArgs];
   unsigned ParsedArgs = 0;
   Token Arg;
   while (ParsedArgs < NumArgs && Retokenizer.lexWord(Arg)) {
-    Args[ParsedArgs] = Argument(SourceRange(Arg.getLocation(),
-                                            Arg.getEndLocation()),
-                                Arg.getText());
+    Args[ParsedArgs] = Comment::Argument{
+        SourceRange(Arg.getLocation(), Arg.getEndLocation()), Arg.getText()};
     ParsedArgs++;
   }
 
-  S.actOnBlockCommandArgs(BC, llvm::makeArrayRef(Args, ParsedArgs));
+  return llvm::makeArrayRef(Args, ParsedArgs);
 }
 
 BlockCommandComment *Parser::parseBlockCommand() {
   assert(Tok.is(tok::backslash_command) || Tok.is(tok::at_command));
 
   ParamCommandComment *PC = nullptr;
   TParamCommandComment *TPC = nullptr;
   BlockCommandComment *BC = nullptr;
if (PC || TPC || Info->NumArgs > 0) {
     // following text tokens.
     TextTokenRetokenizer Retokenizer(Allocator, *this);
 
     if (PC)
       parseParamCommandArgs(PC, Retokenizer);
     else if (TPC)
       parseTParamCommandArgs(TPC, Retokenizer);
     else
-      parseBlockCommandArgs(BC, Retokenizer, Info->NumArgs);
+      S.actOnBlockCommandArgs(BC, parseCommandArgs(Retokenizer, Info->NumArgs));
 
     Retokenizer.putBackLeftoverTokens();
   }
 
   // If there's a block command ahead, we will attach an empty paragraph to
   // this command.
   bool EmptyParagraph = false;
   if (isTokBlockCommand())
BlockCommandComment *Parser::parseBlockCommand() {
   } else {
     S.actOnBlockCommandFinish(BC, Paragraph);
     return BC;
   }
 }
 
 InlineCommandComment *Parser::parseInlineCommand() {
   assert(Tok.is(tok::backslash_command) || Tok.is(tok::at_command));
+  const CommandInfo *Info = Traits.getCommandInfo(Tok.getCommandID());
 
   const Token CommandTok = Tok;
   consumeToken();
 
   TextTokenRetokenizer Retokenizer(Allocator, *this);
+  ArrayRef<Comment::Argument> Args =
+      parseCommandArgs(Retokenizer, Info->NumArgs);
 
-  Token ArgTok;
-  bool ArgTokValid = Retokenizer.lexWord(ArgTok);
-
-  InlineCommandComment *IC;
-  if (ArgTokValid) {
-    IC = S.actOnInlineCommand(CommandTok.getLocation(),
-                              CommandTok.getEndLocation(),
-                              CommandTok.getCommandID(),
-                              ArgTok.getLocation(),
-                              ArgTok.getEndLocation(),
-                              ArgTok.getText());
-  } else {
-    IC = S.actOnInlineCommand(CommandTok.getLocation(),
-                              CommandTok.getEndLocation(),
-                              CommandTok.getCommandID());
+  InlineCommandComment *IC = S.actOnInlineCommand(
+      CommandTok.getLocation(), CommandTok.getEndLocation(),
+      CommandTok.getCommandID(), Args);
 
+  if (Args.size() < Info->NumArgs) {
     Diag(CommandTok.getEndLocation().getLocWithOffset(1),
-         diag::warn_doc_inline_contents_no_argument)
-        << CommandTok.is(tok::at_command)
-        << Traits.getCommandInfo(CommandTok.getCommandID())->Name
+         diag::warn_doc_inline_command_not_enough_arguments)
+        << CommandTok.is(tok::at_command) << Info->Name << Args.size()
+        << Info->NumArgs
         << SourceRange(CommandTok.getLocation(), CommandTok.getEndLocation());
   }
 
   Retokenizer.putBackLeftoverTokens();
 
   return IC;
 }
 

clang/lib/AST/CommentSema.cpp

void Sema::actOnParamCommandParamNameArg(ParamCommandComment *Command,
                                          StringRef Arg) {
   // Parser will not feed us more arguments than needed.
   assert(Command->getNumArgs() == 0);
 
   if (!Command->isDirectionExplicit()) {
     // User didn't provide a direction argument.
     Command->setDirection(ParamCommandComment::In, /* Explicit = */ false);
   }
-  typedef BlockCommandComment::Argument Argument;
-  Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
-                                                     ArgLocEnd),
-                                         Arg);
+  auto *A = new (Allocator)
+      Comment::Argument{SourceRange(ArgLocBegin, ArgLocEnd), Arg};
   Command->setArgs(llvm::makeArrayRef(A, 1));
 }
 
 void Sema::actOnParamCommandFinish(ParamCommandComment *Command,
                                    ParagraphComment *Paragraph) {
   Command->setParagraph(Paragraph);
   checkBlockCommandEmptyParagraph(Command);
 }

 
 void Sema::actOnTParamCommandParamNameArg(TParamCommandComment *Command,
                                           SourceLocation ArgLocBegin,
                                           SourceLocation ArgLocEnd,
                                           StringRef Arg) {
   // Parser will not feed us more arguments than needed.
   assert(Command->getNumArgs() == 0);
 
-  typedef BlockCommandComment::Argument Argument;
-  Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
-                                                     ArgLocEnd),
-                                         Arg);
+  auto *A = new (Allocator)
+      Comment::Argument{SourceRange(ArgLocBegin, ArgLocEnd), Arg};
   Command->setArgs(llvm::makeArrayRef(A, 1));
 
   if (!isTemplateOrSpecialization()) {
     // We already warned that this \\tparam is not attached to a template decl.
     return;
   }
 
   const TemplateParameterList *TemplateParameters =

 }
 
 void Sema::actOnTParamCommandFinish(TParamCommandComment *Command,
                                     ParagraphComment *Paragraph) {
   Command->setParagraph(Paragraph);
   checkBlockCommandEmptyParagraph(Command);
 }
 
-InlineCommandComment *Sema::actOnInlineCommand(SourceLocation CommandLocBegin,
-                                               SourceLocation CommandLocEnd,
-                                               unsigned CommandID) {
-  ArrayRef<InlineCommandComment::Argument> Args;
-  StringRef CommandName = Traits.getCommandInfo(CommandID)->Name;
-  return new (Allocator) InlineCommandComment(
-                                  CommandLocBegin,
-                                  CommandLocEnd,
-                                  CommandID,
-                                  getInlineCommandRenderKind(CommandName),
-                                  Args);
-}
-
-InlineCommandComment *Sema::actOnInlineCommand(SourceLocation CommandLocBegin,
-                                               SourceLocation CommandLocEnd,
-                                               unsigned CommandID,
-                                               SourceLocation ArgLocBegin,
-                                               SourceLocation ArgLocEnd,
-                                               StringRef Arg) {
-  typedef InlineCommandComment::Argument Argument;
-  Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
-                                                     ArgLocEnd),
-                                         Arg);
+InlineCommandComment *
+Sema::actOnInlineCommand(SourceLocation CommandLocBegin,
+                         SourceLocation CommandLocEnd, unsigned CommandID,
+                         ArrayRef<Comment::Argument> Args) {
   StringRef CommandName = Traits.getCommandInfo(CommandID)->Name;
 
-  return new (Allocator) InlineCommandComment(
-                                  CommandLocBegin,
-                                  CommandLocEnd,
-                                  CommandID,
-                                  getInlineCommandRenderKind(CommandName),
-                                  llvm::makeArrayRef(A, 1));
+  return new (Allocator)
+      InlineCommandComment(CommandLocBegin, CommandLocEnd, CommandID,
+                           getInlineCommandRenderKind(CommandName), Args);
 }
 
 InlineContentComment *Sema::actOnUnknownCommand(SourceLocation LocBegin,
                                                 SourceLocation LocEnd,
                                                 StringRef CommandName) {
   unsigned CommandID = Traits.registerUnknownCommand(CommandName)->getID();
   return actOnUnknownCommand(LocBegin, LocEnd, CommandID);
 }

clang/test/AST/ast-dump-comment.cpp

 // CHECK-NEXT:     ParagraphComment
 // CHECK-NEXT:       TextComment{{.*}} Text=" xxx"
 
 /// \c Aaa
 int Test_InlineCommandComment;
 // CHECK:      VarDecl{{.*}}Test_InlineCommandComment
 // CHECK:        InlineCommandComment{{.*}} Name="c" RenderMonospaced Arg[0]="Aaa"
 
+/// \n Aaa
+int Test_InlineCommandComment_NoArgs;
+// CHECK:      VarDecl{{.*}}Test_InlineCommandComment_NoArgs
+// CHECK:        InlineCommandComment{{.*}} Name="n" RenderNormal
+// CHECK-NEXT:   TextComment{{.*}} Text=" Aaa"
+
 /// \anchor Aaa
 int Test_InlineCommandCommentAnchor;
 // CHECK:      VarDecl{{.*}}Test_InlineCommandComment
 // CHECK:        InlineCommandComment{{.*}} Name="anchor" RenderAnchor Arg[0]="Aaa"
 
 /// <a>Aaa</a>
 /// <br/>
 int Test_HTMLTagComment;

clang/test/Headers/x86-intrinsics-headers-clean.cpp

 // Make sure the intrinsic headers compile cleanly with no warnings or errors.
 
 // RUN: %clang_cc1 -ffreestanding -triple i386-unknown-unknown \
-// RUN:    -Wextra -Werror -Wsystem-headers -Wsign-conversion -Wcast-qual -Wdocumentation \
+// RUN:    -Wextra -Werror -Wsystem-headers -Wsign-conversion -Wcast-qual -Wdocumentation -Wdocumentation-pedantic -Wdocumentation-unknown-command \
 // RUN:    -fsyntax-only -fretain-comments-from-system-headers -flax-vector-conversions=none -x c++ -verify %s
 
 // RUN: %clang_cc1 -ffreestanding -triple x86_64-unknown-unknown \
-// RUN:    -Wextra -Werror -Wsystem-headers -Wsign-conversion -Wcast-qual -Wdocumentation \
+// RUN:    -Wextra -Werror -Wsystem-headers -Wsign-conversion -Wcast-qual -Wdocumentation -Wdocumentation-pedantic -Wdocumentation-unknown-command \
 // RUN:    -fsyntax-only -fretain-comments-from-system-headers -flax-vector-conversions=none -x c++ -verify %s
 
 // expected-no-diagnostics
 
 #include <x86intrin.h>

clang/test/Sema/warn-documentation.cpp

struct test_attach38 {
   void test_attach39(T a, B b);
 };
 
 template <>
 template <typename B>
 void test_attach38<int>::test_attach39(int, B);
 
 // The inline comments expect a string after the command.
-// expected-warning@+1 {{'\a' command does not have a valid word argument}}
+// expected-warning@+1 {{'\a' command has no word arguments, expected 1}}
 /// \a
 int test_inline_no_argument_a_bad(int);
 
 /// \a A
 int test_inline_no_argument_a_good(int);
 
-// expected-warning@+1 {{'\anchor' command does not have a valid word argument}}
+// expected-warning@+1 {{'\anchor' command has no word arguments, expected 1}}
 /// \anchor
 int test_inline_no_argument_anchor_bad(int);
 
 /// \anchor A
 int test_inline_no_argument_anchor_good(int);
 
-// expected-warning@+1 {{'@b' command does not have a valid word argument}}
+// expected-warning@+1 {{'@b' command has no word arguments, expected 1}}
 /// @b
 int test_inline_no_argument_b_bad(int);
 
 /// @b A
 int test_inline_no_argument_b_good(int);
 
-// expected-warning@+1 {{'\c' command does not have a valid word argument}}
+// expected-warning@+1 {{'\c' command has no word arguments, expected 1}}
 /// \c
 int test_inline_no_argument_c_bad(int);
 
 /// \c A
 int test_inline_no_argument_c_good(int);
 
-// expected-warning@+1 {{'\e' command does not have a valid word argument}}
+// expected-warning@+1 {{'\e' command has no word arguments, expected 1}}
 /// \e
 int test_inline_no_argument_e_bad(int);
 
 /// \e A
 int test_inline_no_argument_e_good(int);
 
-// expected-warning@+1 {{'\em' command does not have a valid word argument}}
+// expected-warning@+1 {{'\em' command has no word arguments, expected 1}}
 /// \em
 int test_inline_no_argument_em_bad(int);
 
 /// \em A
 int test_inline_no_argument_em_good(int);
 
-// expected-warning@+1 {{'\p' command does not have a valid word argument}}
+// expected-warning@+1 {{'\p' command has no word arguments, expected 1}}
 /// \p
 int test_inline_no_argument_p_bad(int);
 
 /// \p A
 int test_inline_no_argument_p_good(int);
 
 // PR13411, reduced.  We used to crash on this.
 /**