Clang Project

clang_source_code/tools/arcmt-test/arcmt-test.cpp
1//===-- arcmt-test.cpp - ARC Migration Tool testbed -----------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "clang/ARCMigrate/ARCMT.h"
10#include "clang/AST/ASTContext.h"
11#include "clang/Frontend/PCHContainerOperations.h"
12#include "clang/Frontend/TextDiagnosticPrinter.h"
13#include "clang/Frontend/Utils.h"
14#include "clang/Frontend/VerifyDiagnosticConsumer.h"
15#include "clang/Lex/Preprocessor.h"
16#include "clang/Lex/PreprocessorOptions.h"
17#include "llvm/Support/FileSystem.h"
18#include "llvm/Support/MemoryBuffer.h"
19#include "llvm/Support/Path.h"
20#include "llvm/Support/Signals.h"
21#include <system_error>
22
23using namespace clang;
24using namespace arcmt;
25
26static llvm::cl::opt<bool>
27CheckOnly("check-only",
28      llvm::cl::desc("Just check for issues that need to be handled manually"));
29
30//static llvm::cl::opt<bool>
31//TestResultForARC("test-result",
32//llvm::cl::desc("Test the result of transformations by parsing it in ARC mode"));
33
34static llvm::cl::opt<bool>
35OutputTransformations("output-transformations",
36                      llvm::cl::desc("Print the source transformations"));
37
38static llvm::cl::opt<bool>
39VerifyDiags("verify",llvm::cl::desc("Verify emitted diagnostics and warnings"));
40
41static llvm::cl::opt<bool>
42VerboseOpt("v", llvm::cl::desc("Enable verbose output"));
43
44static llvm::cl::opt<bool>
45VerifyTransformedFiles("verify-transformed-files",
46llvm::cl::desc("Read pairs of file mappings (typically the output of "
47               "c-arcmt-test) and compare their contents with the filenames "
48               "provided in command-line"));
49
50static llvm::cl::opt<std::string>
51RemappingsFile("remappings-file",
52               llvm::cl::desc("Pairs of file mappings (typically the output of "
53               "c-arcmt-test)"));
54
55static llvm::cl::list<std::string>
56ResultFiles(llvm::cl::Positional, llvm::cl::desc("<filename>..."));
57
58static llvm::cl::extrahelp extraHelp(
59  "\nusage with compiler args: arcmt-test [options] --args [compiler flags]\n");
60
61// This function isn't referenced outside its translation unit, but it
62// can't use the "static" keyword because its address is used for
63// GetMainExecutable (since some platforms don't support taking the
64// address of main, and some platforms can't implement GetMainExecutable
65// without being given the address of a function in the main executable).
66std::string GetExecutablePath(const char *Argv0) {
67  // This just needs to be some symbol in the binary; C++ doesn't
68  // allow taking the address of ::main however.
69  void *MainAddr = (void*) (intptr_t) GetExecutablePath;
70  return llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
71}
72
73static void printSourceLocation(SourceLocation loc, ASTContext &Ctx,
74                                raw_ostream &OS);
75static void printSourceRange(CharSourceRange range, ASTContext &Ctx,
76                             raw_ostream &OS);
77
78namespace {
79
80class PrintTransforms : public MigrationProcess::RewriteListener {
81  ASTContext *Ctx;
82  raw_ostream &OS;
83
84public:
85  PrintTransforms(raw_ostream &OS)
86    : Ctx(nullptr), OS(OS) {}
87
88  void start(ASTContext &ctx) override { Ctx = &ctx; }
89  void finish() override { Ctx = nullptr; }
90
91  void insert(SourceLocation loc, StringRef text) override {
92    assert(Ctx);
93    OS << "Insert: ";
94    printSourceLocation(loc, *Ctx, OS);
95    OS << " \"" << text << "\"\n";
96  }
97
98  void remove(CharSourceRange range) override {
99    assert(Ctx);
100    OS << "Remove: ";
101    printSourceRange(range, *Ctx, OS);
102    OS << '\n';
103  }
104};
105
106} // anonymous namespace
107
108static bool checkForMigration(StringRef resourcesPath,
109                              ArrayRef<const char *> Args) {
110  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
111  DiagnosticConsumer *DiagClient =
112    new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
113  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
114  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
115      new DiagnosticsEngine(DiagID, &*DiagOpts, DiagClient));
116  // Chain in -verify checker, if requested.
117  VerifyDiagnosticConsumer *verifyDiag = nullptr;
118  if (VerifyDiags) {
119    verifyDiag = new VerifyDiagnosticConsumer(*Diags);
120    Diags->setClient(verifyDiag);
121  }
122
123  CompilerInvocation CI;
124  if (!CompilerInvocation::CreateFromArgs(CI, Args.begin(), Args.end(), *Diags))
125    return true;
126
127  if (CI.getFrontendOpts().Inputs.empty()) {
128    llvm::errs() << "error: no input files\n";
129    return true;
130  }
131
132  if (!CI.getLangOpts()->ObjC)
133    return false;
134
135  arcmt::checkForManualIssues(CI, CI.getFrontendOpts().Inputs[0],
136                              std::make_shared<PCHContainerOperations>(),
137                              Diags->getClient());
138  return Diags->getClient()->getNumErrors() > 0;
139}
140
141static void printResult(FileRemapper &remapper, raw_ostream &OS) {
142  PreprocessorOptions PPOpts;
143  remapper.applyMappings(PPOpts);
144  // The changed files will be in memory buffers, print them.
145  for (const auto &RB : PPOpts.RemappedFileBuffers)
146    OS << RB.second->getBuffer();
147}
148
149static bool performTransformations(StringRef resourcesPath,
150                                   ArrayRef<const char *> Args) {
151  // Check first.
152  if (checkForMigration(resourcesPath, Args))
153    return true;
154
155  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
156  DiagnosticConsumer *DiagClient =
157    new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
158  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
159  IntrusiveRefCntPtr<DiagnosticsEngine> TopDiags(
160      new DiagnosticsEngine(DiagID, &*DiagOpts, &*DiagClient));
161
162  CompilerInvocation origCI;
163  if (!CompilerInvocation::CreateFromArgs(origCI, Args.begin(), Args.end(),
164                                     *TopDiags))
165    return true;
166
167  if (origCI.getFrontendOpts().Inputs.empty()) {
168    llvm::errs() << "error: no input files\n";
169    return true;
170  }
171
172  if (!origCI.getLangOpts()->ObjC)
173    return false;
174
175  MigrationProcess migration(origCI, std::make_shared<PCHContainerOperations>(),
176                             DiagClient);
177
178  std::vector<TransformFn>
179    transforms = arcmt::getAllTransformations(origCI.getLangOpts()->getGC(),
180                                 origCI.getMigratorOpts().NoFinalizeRemoval);
181  assert(!transforms.empty());
182
183  std::unique_ptr<PrintTransforms> transformPrinter;
184  if (OutputTransformations)
185    transformPrinter.reset(new PrintTransforms(llvm::outs()));
186
187  for (unsigned i=0, e = transforms.size(); i != e; ++i) {
188    bool err = migration.applyTransform(transforms[i], transformPrinter.get());
189    if (err) return true;
190
191    if (VerboseOpt) {
192      if (i == e-1)
193        llvm::errs() << "\n##### FINAL RESULT #####\n";
194      else
195        llvm::errs() << "\n##### OUTPUT AFTER "<< i+1 <<". TRANSFORMATION #####\n";
196      printResult(migration.getRemapper(), llvm::errs());
197      llvm::errs() << "\n##########################\n\n";
198    }
199  }
200
201  if (!OutputTransformations)
202    printResult(migration.getRemapper(), llvm::outs());
203
204  // FIXME: TestResultForARC
205
206  return false;
207}
208
209static bool filesCompareEqual(StringRef fname1, StringRef fname2) {
210  using namespace llvm;
211
212  ErrorOr<std::unique_ptr<MemoryBuffer>> file1 = MemoryBuffer::getFile(fname1);
213  if (!file1)
214    return false;
215
216  ErrorOr<std::unique_ptr<MemoryBuffer>> file2 = MemoryBuffer::getFile(fname2);
217  if (!file2)
218    return false;
219
220  return file1.get()->getBuffer() == file2.get()->getBuffer();
221}
222
223static bool verifyTransformedFiles(ArrayRef<std::string> resultFiles) {
224  using namespace llvm;
225
226  assert(!resultFiles.empty());
227
228  std::map<StringRef, StringRef> resultMap;
229
230  for (ArrayRef<std::string>::iterator
231         I = resultFiles.begin(), E = resultFiles.end(); I != E; ++I) {
232    StringRef fname(*I);
233    if (!fname.endswith(".result")) {
234      errs() << "error: filename '" << fname
235                   << "' does not have '.result' extension\n";
236      return true;
237    }
238    resultMap[sys::path::stem(fname)] = fname;
239  }
240
241  ErrorOr<std::unique_ptr<MemoryBuffer>> inputBuf = std::error_code();
242  if (RemappingsFile.empty())
243    inputBuf = MemoryBuffer::getSTDIN();
244  else
245    inputBuf = MemoryBuffer::getFile(RemappingsFile);
246  if (!inputBuf) {
247    errs() << "error: could not read remappings input\n";
248    return true;
249  }
250
251  SmallVector<StringRef, 8> strs;
252  inputBuf.get()->getBuffer().split(strs, "\n", /*MaxSplit=*/-1,
253                                    /*KeepEmpty=*/false);
254
255  if (strs.empty()) {
256    errs() << "error: no files to verify from stdin\n";
257    return true;
258  }
259  if (strs.size() % 2 != 0) {
260    errs() << "error: files to verify are not original/result pairs\n";
261    return true;
262  }
263
264  for (unsigned i = 0, e = strs.size(); i != e; i += 2) {
265    StringRef inputOrigFname = strs[i];
266    StringRef inputResultFname = strs[i+1];
267
268    std::map<StringRef, StringRef>::iterator It;
269    It = resultMap.find(sys::path::filename(inputOrigFname));
270    if (It == resultMap.end()) {
271      errs() << "error: '" << inputOrigFname << "' is not in the list of "
272             << "transformed files to verify\n";
273      return true;
274    }
275
276    if (!sys::fs::exists(It->second)) {
277      errs() << "error: '" << It->second << "' does not exist\n";
278      return true;
279    }
280    if (!sys::fs::exists(inputResultFname)) {
281      errs() << "error: '" << inputResultFname << "' does not exist\n";
282      return true;
283    }
284
285    if (!filesCompareEqual(It->second, inputResultFname)) {
286      errs() << "error: '" << It->second << "' is different than "
287             << "'" << inputResultFname << "'\n";
288      return true;
289    }
290
291    resultMap.erase(It);
292  }
293
294  if (!resultMap.empty()) {
295    for (std::map<StringRef, StringRef>::iterator
296           I = resultMap.begin(), E = resultMap.end(); I != E; ++I)
297      errs() << "error: '" << I->second << "' was not verified!\n";
298    return true;
299  }
300
301  return false; 
302}
303
304//===----------------------------------------------------------------------===//
305// Misc. functions.
306//===----------------------------------------------------------------------===//
307
308static void printSourceLocation(SourceLocation loc, ASTContext &Ctx,
309                                raw_ostream &OS) {
310  SourceManager &SM = Ctx.getSourceManager();
311  PresumedLoc PL = SM.getPresumedLoc(loc);
312
313  OS << llvm::sys::path::filename(PL.getFilename());
314  OS << ":" << PL.getLine() << ":"
315            << PL.getColumn();
316}
317
318static void printSourceRange(CharSourceRange range, ASTContext &Ctx,
319                             raw_ostream &OS) {
320  SourceManager &SM = Ctx.getSourceManager();
321  const LangOptions &langOpts = Ctx.getLangOpts();
322
323  PresumedLoc PL = SM.getPresumedLoc(range.getBegin());
324
325  OS << llvm::sys::path::filename(PL.getFilename());
326  OS << " [" << PL.getLine() << ":"
327             << PL.getColumn();
328  OS << " - ";
329
330  SourceLocation end = range.getEnd();
331  PL = SM.getPresumedLoc(end);
332
333  unsigned endCol = PL.getColumn() - 1;
334  if (!range.isTokenRange())
335    endCol += Lexer::MeasureTokenLength(end, SM, langOpts);
336  OS << PL.getLine() << ":" << endCol << "]";
337}
338
339//===----------------------------------------------------------------------===//
340// Command line processing.
341//===----------------------------------------------------------------------===//
342
343int main(int argc, const char **argv) {
344  void *MainAddr = (void*) (intptr_t) GetExecutablePath;
345  llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
346
347  std::string
348    resourcesPath = CompilerInvocation::GetResourcesPath(argv[0], MainAddr);
349
350  int optargc = 0;
351  for (; optargc != argc; ++optargc) {
352    if (StringRef(argv[optargc]) == "--args")
353      break;
354  }
355  llvm::cl::ParseCommandLineOptions(optargc, argv, "arcmt-test");
356
357  if (VerifyTransformedFiles) {
358    if (ResultFiles.empty()) {
359      llvm::cl::PrintHelpMessage();
360      return 1;
361    }
362    return verifyTransformedFiles(ResultFiles);
363  }
364
365  if (optargc == argc) {
366    llvm::cl::PrintHelpMessage();
367    return 1;
368  }
369
370  ArrayRef<const char*> Args(argv+optargc+1, argc-optargc-1);
371
372  if (CheckOnly)
373    return checkForMigration(resourcesPath, Args);
374
375  return performTransformations(resourcesPath, Args);
376}
377
CodeThinker, Enjoy your reading code