[PATCH] Repost using Phabricator of ArgumentsAdjuster change (part 1)

[jtsoftware]

Summary

This is just a repost of the patch from the email entitled "{PATCH] clang::tooling::ArgumentAdjuster - Add file name argument to Adjust callback" redone using Phabricator for the first time.

Note that there is another part coming from the separate repository for clang-extra-tools. Can these be put into one Phabricator post? Maybe I need to paste the combined text instead of a patch file link.

[jtsoftware]

I handled it a different way.

include/clang/Tooling/ArgumentsAdjusters.h

 // These classes are intended to 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 "llvm/ADT/StringRef.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 
 namespace tooling {
 
 /// \brief A sequence of command line arguments.
 typedef std::vector<std::string> CommandLineArguments;
 
 /// \brief Abstract interface for a command line adjusters.
 ///
 /// This abstract interface describes a command line argument adjuster,
 /// which is responsible for command line arguments modification before
 /// the arguments are used to run a frontend action.
 class ArgumentsAdjuster {
   virtual void anchor();
 public:
   /// \brief Returns adjusted command line arguments.
   ///
+  /// \param InputFile Input file.
   /// \param Args Input sequence of command line arguments.
   ///
   /// \returns Modified sequence of command line arguments.
-  virtual CommandLineArguments Adjust(const CommandLineArguments &Args) = 0;
+  virtual CommandLineArguments Adjust(llvm::StringRef InputFile,
+                                      const CommandLineArguments &Args) = 0;
   virtual ~ArgumentsAdjuster() {
   }
 };
 
 /// \brief Syntax check only command line adjuster.
 ///
 /// This class implements ArgumentsAdjuster interface and converts input
 /// command line arguments to the "syntax check only" variant.
 class ClangSyntaxOnlyAdjuster : public ArgumentsAdjuster {
-  virtual CommandLineArguments Adjust(const CommandLineArguments &Args);
+  virtual CommandLineArguments Adjust(llvm::StringRef InputFile,
+                                      const CommandLineArguments &Args);
 };
 
 /// \brief An argument adjuster which removes output-related command line
 /// arguments.
 class ClangStripOutputAdjuster : public ArgumentsAdjuster {
-  virtual CommandLineArguments Adjust(const CommandLineArguments &Args);
+  virtual CommandLineArguments Adjust(llvm::StringRef InputFile,
+                                      const CommandLineArguments &Args);
 };
 
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_ARGUMENTSADJUSTERS_H
 

lib/Tooling/ArgumentsAdjusters.cpp

 namespace clang {
 namespace tooling {
 
 void ArgumentsAdjuster::anchor() {
 }
 
 /// Add -fsyntax-only option to the commnand line arguments.
 CommandLineArguments
-ClangSyntaxOnlyAdjuster::Adjust(const CommandLineArguments &Args) {
+ClangSyntaxOnlyAdjuster::Adjust(StringRef InputFile,
+                                const CommandLineArguments &Args) {
   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;
 }
 
 CommandLineArguments
-ClangStripOutputAdjuster::Adjust(const CommandLineArguments &Args) {
+ClangStripOutputAdjuster::Adjust(llvm::StringRef InputFile,
+                                 const CommandLineArguments &Args) {
   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.

lib/Tooling/Tooling.cpp

for (unsigned I = 0; I < CompileCommands.size(); ++I) {
     // for example on network filesystems, where symlinks might be switched
     // during runtime of the tool. Fixing this depends on having a file system
     // abstraction that allows openat() style interactions.
     if (chdir(CompileCommands[I].second.Directory.c_str()))
       llvm::report_fatal_error("Cannot chdir into \"" +
                                CompileCommands[I].second.Directory + "\n!");
     std::vector<std::string> CommandLine = CompileCommands[I].second.CommandLine;
     for (unsigned I = 0, E = ArgsAdjusters.size(); I != E; ++I)
-      CommandLine = ArgsAdjusters[I]->Adjust(CommandLine);
+      CommandLine = ArgsAdjusters[I]->Adjust(File, CommandLine);
     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(CommandLine, ActionFactory->create(), &Files);

tools/clang-check/ClangCheck.cpp

InsertAdjuster(const CommandLineArguments &Extra, Position Pos)
     : Extra(Extra), Pos(Pos) {
   }
 
   InsertAdjuster(const char *Extra, Position Pos)
     : Extra(1, std::string(Extra)), Pos(Pos) {
   }
 
   virtual CommandLineArguments
-  Adjust(const CommandLineArguments &Args) LLVM_OVERRIDE {
+  Adjust(llvm::StringRef InputFile,
+         const CommandLineArguments &Args) LLVM_OVERRIDE {
     CommandLineArguments Return(Args);
 
     CommandLineArguments::iterator I;
     if (Pos == END) {
       I = Return.end();
     } else {
       I = Return.begin();
       ++I; // To leave the program name in place

unittests/Tooling/ToolingTest.cpp

EXPECT_TRUE(runToolOnCode(new SkipBodyAction,
                             "int skipMe() { an_error_here }"));
   EXPECT_FALSE(runToolOnCode(new SkipBodyAction,
                              "int skipMeNot() { an_error_here }"));
 }
 
 struct CheckSyntaxOnlyAdjuster: public ArgumentsAdjuster {
   bool &Found;
   bool &Ran;
+  std::string &File;
 
-  CheckSyntaxOnlyAdjuster(bool &Found, bool &Ran) : Found(Found), Ran(Ran) { }
+  CheckSyntaxOnlyAdjuster(bool &Found, bool &Ran, std::string &File)
+    : Found(Found), Ran(Ran), File(File) { }
 
   virtual CommandLineArguments
-  Adjust(const CommandLineArguments &Args) LLVM_OVERRIDE {
+  Adjust(llvm::StringRef InputFile,
+         const CommandLineArguments &Args) LLVM_OVERRIDE {
     Ran = true;
     for (unsigned I = 0, E = Args.size(); I != E; ++I) {
       if (Args[I] == "-fsyntax-only") {
         Found = true;
         break;
       }
     }
+    File = InputFile;
     return Args;
   }
 };
 
 TEST(ClangToolTest, ArgumentAdjusters) {
   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
 
   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
   Tool.mapVirtualFile("/a.cc", "void a() {}");
 
   bool Found = false;
   bool Ran = false;
-  Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran));
+  std::string File;
+  Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran, File));
   Tool.run(newFrontendActionFactory<SyntaxOnlyAction>());
   EXPECT_TRUE(Ran);
   EXPECT_TRUE(Found);
+  EXPECT_TRUE(File.compare(File.length() - 4, 4, "a.cc") == 0);
 
   Ran = Found = false;
+  File.clear();
   Tool.clearArgumentsAdjusters();
-  Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran));
+  Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran, File));
   Tool.appendArgumentsAdjuster(new ClangSyntaxOnlyAdjuster());
   Tool.run(newFrontendActionFactory<SyntaxOnlyAction>());
   EXPECT_TRUE(Ran);
   EXPECT_FALSE(Found);
+  EXPECT_TRUE(File.compare(File.length() - 4, 4, "a.cc") == 0);
 }
 
 } // end namespace tooling
 } // end namespace clang