[clang-tidy] Silence modernize-redundant-void-arg in the case of vexing parses

[george.burgess.iv]

Summary

Clang's -Wvexing-parse is enabled by default. When the vexing statement was _intended_ to be interpreted as a function that takes zero arguments, the function's declaration can be rewritten as T foo(void); to silence -Wvexing-parse. This workaround seems to upset clang-tidy.

Given my own lack of understanding of the corners of C++ parsing, I'm... not entirely confident that this patch catches everything && has no unintended side-effects. The bits that -Wvexing-parse depends upon are stored within DeclaratorChunk::FunctionTypeInfos, which seem to only exist during AST formation, so it's not clear to me how to directly get at that information from clang-tidy.

[LegalizeAdulthood]

Clang-Tidy tests and docs have moved to module subdirectories.

Please rebase this onto main:HEAD and:

• fold your changes into the appropriate subdirs, stripping the module prefix from new files.
• make the target check-clang-extra to validate your tests
• make the target docs-clang-tools-html to validate any docs changes

[george.burgess.iv]

Rebased on top of 891319f654c102572cf7028ed04bbaf6c59e7bff as requested; ninja check-clang-extra docs-clang-tools-html passes

[LegalizeAdulthood]

clang-tools-extra/test/clang-tidy/checkers/modernize/redundant-void-arg.cpp

596 ↗

(On Diff #444397)

This is not the only way to eliminate the vexing parse warning. For instance, if the intention is to declare foo as a function not in this translation unit, then:

void most_vexing_parse() {
  extern int foo();
}

does the trick.

Why assume that the only way to fix vexing-parse is to add (void)?

clang-tools-extra/clang-tidy/modernize/RedundantVoidArgCheck.cpp

if (const Stmt *Body = Function->getBody()) {
       End = Body->getBeginLoc();
       if (End.isMacroID() &&
           Result.SourceManager->isAtStartOfImmediateMacroExpansion(End))
         End = Result.SourceManager->getExpansionLoc(End);
       End = End.getLocWithOffset(-1);
     }
     removeVoidArgumentTokens(Result, SourceRange(Start, End),
                              "function definition");
-  } else
+  } else if (!Function->getLexicalDeclContext()->isFunctionOrMethod()) {
+    // Only do this if our decl context is outside of a function or method;
+    // otherwise, the user may have explicitly written `(void)` to avoid Most
+    // Vexing Parse warnings.
     removeVoidArgumentTokens(Result, SourceRange(Start, End),
                              "function declaration");
   }
+}
 
 bool isMacroIdentifier(const IdentifierTable &Idents, const Token &ProtoToken) {
   if (!ProtoToken.is(tok::TokenKind::raw_identifier))
     return false;
 
   IdentifierTable::iterator It = Idents.find(ProtoToken.getRawIdentifier());
   if (It == Idents.end())
     return false;

clang-tools-extra/test/clang-tidy/checkers/modernize-redundant-void-arg.cpp

 
 return_t(return_t(void)) func2(return_t(return_t(void)) (*fp)(void)) {
   // CHECK-MESSAGES: :[[@LINE-1]]:63: warning: redundant void argument list in variable declaration
   // CHECK-FIXES: return_t(return_t(void)) func2(return_t(return_t(void)) (*fp)()) {
   int a;
   (void)a;
 }
 #undef return_t
+
+// Explicitly specifying `(void)` is a way to sidestep -Wvexing-parse, so we
+// should not warn about it here.
+void most_vexing_parse() {
+  int foo(void);
+}