Make ArgumentAdjuster aware of the current file being processed.

[alexfh]

Summary

This is needed to handle per-project configurations when adding extra
arguments in clang-tidy for example.

[alexfh]

Ping.

[alexfh]

Ping.

[djasper]

Looks good.

include/clang/Tooling/ArgumentsAdjusters.h

 // ArgumentsAdjusters modify command line arguments obtained from a compilation
 // database before they are used to run a frontend action.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLING_ARGUMENTSADJUSTERS_H
 #define LLVM_CLANG_TOOLING_ARGUMENTSADJUSTERS_H
 
+#include "clang/Basic/LLVM.h"
+#include "llvm/ADT/StringRef.h"
 #include <functional>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace tooling {
 
 /// \brief A sequence of command line arguments.
 typedef std::vector<std::string> CommandLineArguments;
 
 /// \brief A prototype of a command line adjuster.
 ///
 /// Command line argument adjuster is responsible for command line arguments
 /// modification before the arguments are used to run a frontend action.
-typedef std::function<CommandLineArguments(const CommandLineArguments &)>
-    ArgumentsAdjuster;
+typedef std::function<CommandLineArguments(
+    const CommandLineArguments &, StringRef Filename)> ArgumentsAdjuster;
 
 /// \brief Gets an argument adjuster that converts input command line arguments
 /// to the "syntax check only" variant.
 ArgumentsAdjuster getClangSyntaxOnlyAdjuster();
 
 /// \brief Gets an argument adjuster which removes output-related command line
 /// arguments.
 ArgumentsAdjuster getClangStripOutputAdjuster();

lib/Tooling/ArgumentsAdjusters.cpp

 //===--- ArgumentsAdjusters.cpp - Command line arguments adjuster ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains definitions of classes which implement ArgumentsAdjuster
 // interface.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/ArgumentsAdjusters.h"
-#include "clang/Basic/LLVM.h"
-#include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace tooling {
 
 /// Add -fsyntax-only option to the commnand line arguments.
 ArgumentsAdjuster getClangSyntaxOnlyAdjuster() {
-  return [](const CommandLineArguments &Args) {
+  return [](const CommandLineArguments &Args, StringRef /*unused*/) {
     CommandLineArguments AdjustedArgs;
     for (size_t i = 0, e = Args.size(); i != e; ++i) {
       StringRef Arg = Args[i];
       // FIXME: Remove options that generate output.
       if (!Arg.startswith("-fcolor-diagnostics") &&
           !Arg.startswith("-fdiagnostics-color"))
         AdjustedArgs.push_back(Args[i]);
     }
     AdjustedArgs.push_back("-fsyntax-only");
     return AdjustedArgs;
   };
 }
 
 ArgumentsAdjuster getClangStripOutputAdjuster() {
-  return [](const CommandLineArguments &Args) {
+  return [](const CommandLineArguments &Args, StringRef /*unused*/) {
     CommandLineArguments AdjustedArgs;
     for (size_t i = 0, e = Args.size(); i < e; ++i) {
       StringRef Arg = Args[i];
       if (!Arg.startswith("-o"))
         AdjustedArgs.push_back(Args[i]);
 
       if (Arg == "-o") {
         // Output is specified as -o foo. Skip the next argument also.
         ++i;
       }
       // Else, the output is specified as -ofoo. Just do nothing.
     }
     return AdjustedArgs;
   };
 }
 
 ArgumentsAdjuster getInsertArgumentAdjuster(const CommandLineArguments &Extra,
                                             ArgumentInsertPosition Pos) {
-  return [Extra, Pos](const CommandLineArguments &Args) {
+  return [Extra, Pos](const CommandLineArguments &Args, StringRef /*unused*/) {
     CommandLineArguments Return(Args);
 
     CommandLineArguments::iterator I;
     if (Pos == ArgumentInsertPosition::END) {
       I = Return.end();
     } else {
       I = Return.begin();
       ++I; // To leave the program name in place
     }
 
     Return.insert(I, Extra.begin(), Extra.end());
     return Return;
   };
 }
 
 ArgumentsAdjuster getInsertArgumentAdjuster(const char *Extra,
                                             ArgumentInsertPosition Pos) {
   return getInsertArgumentAdjuster(CommandLineArguments(1, Extra), Pos);
 }
 
 ArgumentsAdjuster combineAdjusters(ArgumentsAdjuster First,
                                    ArgumentsAdjuster Second) {
-  return [First, Second](const CommandLineArguments &Args) {
-    return Second(First(Args));
+  return [First, Second](const CommandLineArguments &Args, StringRef File) {
+    return Second(First(Args, File), File);
   };
 }
 
 } // end namespace tooling
 } // end namespace clang
 

lib/Tooling/CommonOptionsParser.cpp

 private:
   std::unique_ptr<CompilationDatabase> Compilations;
   std::vector<ArgumentsAdjuster> Adjusters;
 
   std::vector<CompileCommand>
   adjustCommands(std::vector<CompileCommand> Commands) const {
     for (CompileCommand &Command : Commands)
       for (const auto &Adjuster : Adjusters)
-        Command.CommandLine = Adjuster(Command.CommandLine);
+        Command.CommandLine = Adjuster(Command.CommandLine, Command.Filename);
     return Commands;
   }
 };
 } // namespace
 
 CommonOptionsParser::CommonOptionsParser(
     int &argc, const char **argv, cl::OptionCategory &Category,
     llvm::cl::NumOccurrencesFlag OccurrencesFlag, const char *Overview) {

lib/Tooling/Tooling.cpp

for (CompileCommand &CompileCommand : CompileCommandsForFile) {
         for (const auto &MappedFile : MappedFileContents)
           if (!llvm::sys::path::is_absolute(MappedFile.first))
             InMemoryFileSystem->addFile(
                 MappedFile.first, 0,
                 llvm::MemoryBuffer::getMemBuffer(MappedFile.second));
 
       std::vector<std::string> CommandLine = CompileCommand.CommandLine;
       if (ArgsAdjuster)
-        CommandLine = ArgsAdjuster(CommandLine);
+        CommandLine = ArgsAdjuster(CommandLine, CompileCommand.Filename);
       assert(!CommandLine.empty());
       CommandLine[0] = MainExecutable;
       // FIXME: We need a callback mechanism for the tool writer to output a
       // customized message for each file.
       DEBUG({ llvm::dbgs() << "Processing: " << File << ".\n"; });
       ToolInvocation Invocation(std::move(CommandLine), Action, Files.get(),
                                 PCHContainerOps);
       Invocation.setDiagnosticConsumer(DiagConsumer);

unittests/Tooling/ToolingTest.cpp

TEST(ClangToolTest, ArgumentAdjusters) {
   Tool.mapVirtualFile("/a.cc", "void a() {}");
 
   std::unique_ptr<FrontendActionFactory> Action(
       newFrontendActionFactory<SyntaxOnlyAction>());
 
   bool Found = false;
   bool Ran = false;
   ArgumentsAdjuster CheckSyntaxOnlyAdjuster =
-      [&Found, &Ran](const CommandLineArguments &Args) {
+      [&Found, &Ran](const CommandLineArguments &Args, StringRef /*unused*/) {
     Ran = true;
     if (std::find(Args.begin(), Args.end(), "-fsyntax-only") != Args.end())
       Found = true;
     return Args;
   };
   Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster);
   Tool.run(Action.get());
   EXPECT_TRUE(Ran);