[clang-tidy] Add '-target' CLI option to override target triple

[jubnzv]

Summary

The added option allows the user to specify the target for which clang-tidy checks will be executed. This is necessary for users who run the tool on project that compiles for a different target platform.

This option also makes it easier to test of clang-tidy and allows to run platform-specific tests on any host system.
This will fix the failed tests when they are run on a Windows host, but the toolchain is targeted a non-Windows platform. The problem is described here: https://reviews.llvm.org/D101259#2739466.

[njames93]

This change doesn't seem to accomplish anything. We can already set the target via the compile command.
This can be done in the compilation database directly or by using the extra-arg and extra-arg-before command line arguments.
If you're not using a compilation database, then you can pass the compile command to clang-tidy after an empty -- argument.

For the test case, this is sufficient to fix the issue:

// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-vararg %t -- --extra-arg=--target=x86_64-windows

EDIT:
For the test, the arch isn't needed --target=unknown-windows is more than sufficient.

[jubnzv]

Thank you, I didn't know that it is possible to set the target triple using --extra-arg. I created a new revision with this fix: https://reviews.llvm.org/D102337.
For some reasons, the --target=unknown-windows doesn't work for me with the following error: error: unknown target triple 'unknown-unknown-windows-msvc19.11.0', please use -triple or -arch [clang-diagnostic-error].
But --target=x86_64-windows works fine.

clang-tools-extra/clang-tidy/ClangTidy.h

 /// the profile will not be output to stderr, but will instead be stored
 /// as a JSON file in the specified directory.
 std::vector<ClangTidyError>
 runClangTidy(clang::tidy::ClangTidyContext &Context,
              const tooling::CompilationDatabase &Compilations,
              ArrayRef<std::string> InputFiles,
              llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> BaseFS,
              bool ApplyAnyFix, bool EnableCheckProfile = false,
+             const std::string &TargetTriple = "",
              llvm::StringRef StoreCheckProfile = StringRef());
 
 /// Controls what kind of fixes clang-tidy is allowed to apply.
 enum FixBehaviour {
   /// Don't try to apply any fix.
   FB_NoFix,
   /// Only apply fixes added to warnings.
   FB_Fix,

clang-tools-extra/clang-tidy/ClangTidy.cpp

getCheckOptions(const ClangTidyOptions &Options,
   clang::tidy::ClangTidyContext Context(
       std::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
                                                 Options),
       AllowEnablingAnalyzerAlphaCheckers);
   ClangTidyASTConsumerFactory Factory(Context);
   return Factory.getCheckOptions();
 }
 
-std::vector<ClangTidyError>
-runClangTidy(clang::tidy::ClangTidyContext &Context,
-             const CompilationDatabase &Compilations,
-             ArrayRef<std::string> InputFiles,
-             llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> BaseFS,
-             bool ApplyAnyFix, bool EnableCheckProfile,
-             llvm::StringRef StoreCheckProfile) {
+std::vector<ClangTidyError> runClangTidy(
+    clang::tidy::ClangTidyContext &Context,
+    const CompilationDatabase &Compilations, ArrayRef<std::string> InputFiles,
+    bool ApplyAnyFix, bool EnableCheckProfile, const std::string &TargetTriple,
   ClangTool Tool(Compilations, InputFiles,
                  std::make_shared<PCHContainerOperations>(), BaseFS);
 
   // Add extra arguments passed by the clang-tidy command-line.
   ArgumentsAdjuster PerFileExtraArgumentsInserter =
-      [&Context](const CommandLineArguments &Args, StringRef Filename) {
+      [&Context, &TargetTriple](const CommandLineArguments &Args,
+                                StringRef Filename) {
         ClangTidyOptions Opts = Context.getOptionsForFile(Filename);
         CommandLineArguments AdjustedArgs = Args;
+        if (!TargetTriple.empty())
+          AdjustedArgs.push_back("--target=" + TargetTriple);
         if (Opts.ExtraArgsBefore) {
           auto I = AdjustedArgs.begin();
           if (I != AdjustedArgs.end() && !StringRef(*I).startswith("-"))
             ++I; // Skip compiler binary name, if it is there.
           AdjustedArgs.insert(I, Opts.ExtraArgsBefore->begin(),
                               Opts.ExtraArgsBefore->end());
         }
         if (Opts.ExtraArgs)

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

 Use colors in diagnostics. If not set, colors
 will be used if the terminal connected to
 standard output supports colors.
 This option overrides the 'UseColor' option in
 .clang-tidy file, if any.
 )"),
                               cl::init(false), cl::cat(ClangTidyCategory));
 
+static cl::opt<std::string> TargetTriple("target", cl::desc(R"(
+Override target triple for clang-tidy. If not set, the host target will be
+used.)"),
+                                         cl::init(""),
+                                         cl::cat(ClangTidyCategory));
+
 namespace clang {
 namespace tidy {
 
 static void printStats(const ClangTidyStats &Stats) {
   if (Stats.errorsIgnored()) {
     llvm::errs() << "Suppressed " << Stats.errorsIgnored() << " warnings (";
     StringRef Separator = "";
     if (Stats.ErrorsIgnoredNonUserCode) {
if (PathList.empty()) {
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return 1;
   }
 
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
 
+  if (!TargetTriple.empty()) {
+    TargetTriple = Triple::normalize(TargetTriple);
+    auto T = Triple(TargetTriple);
+    if (T.getArch() == Triple::UnknownArch) {
+      llvm::errs() << "Error: unknown target triple '" << TargetTriple << "'\n";
+      return 1;
+    }
+  }
+
   ClangTidyContext Context(std::move(OwningOptionsProvider),
                            AllowEnablingAnalyzerAlphaCheckers);
   std::vector<ClangTidyError> Errors =
       runClangTidy(Context, OptionsParser->getCompilations(), PathList, BaseFS,
-                   FixNotes, EnableCheckProfile, ProfilePrefix);
+                   FixNotes, EnableCheckProfile, TargetTriple, ProfilePrefix);
   bool FoundErrors = llvm::find_if(Errors, [](const ClangTidyError &E) {
                        return E.DiagLevel == ClangTidyError::Error;
                      }) != Errors.end();
 
   // --fix-errors and --fix-notes imply --fix.
   FixBehaviour Behaviour = FixNotes             ? FB_FixNotes
                            : (Fix || FixErrors) ? FB_Fix
                                                 : FB_NoFix;

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-pro-type-vararg-ms.cpp

 // Purpose:
 // Ensure that the 'cppcoreguidelines-pro-type-vararg' check works with the
 // built-in va_list on Windows systems.
 
-// REQUIRES: system-windows
-
-// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-vararg %t
+// RUN: %check_clang_tidy -target="x86_64-windows" %s cppcoreguidelines-pro-type-vararg %t
 
 void test_ms_va_list(int a, ...) {
   __builtin_ms_va_list ap;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare variables of type va_list; use variadic templates instead
   __builtin_ms_va_start(ap, a);
   int b = __builtin_va_arg(ap, int);
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: do not use va_arg to define c-style vararg functions; use variadic templates instead
   __builtin_ms_va_end(ap);