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: Argv0, MainExecAddr: 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&: *Ctx, OS);
95 OS << " \"" << text << "\"\n";
96 }
97
98 void remove(CharSourceRange range) override {
99 assert(Ctx);
100 OS << "Remove: ";
101 printSourceRange(range, Ctx&: *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(client: verifyDiag);
121 }
122
123 CompilerInvocation CI;
124 if (!CompilerInvocation::CreateFromArgs(Res&: CI, CommandLineArgs: Args, Diags&: *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, Input: CI.getFrontendOpts().Inputs[0],
136 PCHContainerOps: std::make_shared<PCHContainerOperations>(),
137 DiagClient: Diags->getClient());
138 return Diags->getClient()->getNumErrors() > 0;
139}
140
141static void printResult(FileRemapper &remapper, raw_ostream &OS) {
142 remapper.forEachMapping(CaptureFile: [](StringRef, StringRef) {},
143 CaptureBuffer: [&](StringRef, const llvm::MemoryBufferRef &Buffer) {
144 OS << Buffer.getBuffer();
145 });
146}
147
148static bool performTransformations(StringRef resourcesPath,
149 ArrayRef<const char *> Args) {
150 // Check first.
151 if (checkForMigration(resourcesPath, Args))
152 return true;
153
154 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
155 DiagnosticConsumer *DiagClient =
156 new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
157 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
158 IntrusiveRefCntPtr<DiagnosticsEngine> TopDiags(
159 new DiagnosticsEngine(DiagID, &*DiagOpts, &*DiagClient));
160
161 CompilerInvocation origCI;
162 if (!CompilerInvocation::CreateFromArgs(Res&: origCI, CommandLineArgs: Args, Diags&: *TopDiags))
163 return true;
164
165 if (origCI.getFrontendOpts().Inputs.empty()) {
166 llvm::errs() << "error: no input files\n";
167 return true;
168 }
169
170 if (!origCI.getLangOpts().ObjC)
171 return false;
172
173 MigrationProcess migration(origCI, std::make_shared<PCHContainerOperations>(),
174 DiagClient);
175
176 std::vector<TransformFn>
177 transforms = arcmt::getAllTransformations(OrigGCMode: origCI.getLangOpts().getGC(),
178 NoFinalizeRemoval: origCI.getMigratorOpts().NoFinalizeRemoval);
179 assert(!transforms.empty());
180
181 std::unique_ptr<PrintTransforms> transformPrinter;
182 if (OutputTransformations)
183 transformPrinter.reset(p: new PrintTransforms(llvm::outs()));
184
185 for (unsigned i=0, e = transforms.size(); i != e; ++i) {
186 bool err = migration.applyTransform(trans: transforms[i], listener: transformPrinter.get());
187 if (err) return true;
188
189 if (VerboseOpt) {
190 if (i == e-1)
191 llvm::errs() << "\n##### FINAL RESULT #####\n";
192 else
193 llvm::errs() << "\n##### OUTPUT AFTER "<< i+1 <<". TRANSFORMATION #####\n";
194 printResult(remapper&: migration.getRemapper(), OS&: llvm::errs());
195 llvm::errs() << "\n##########################\n\n";
196 }
197 }
198
199 if (!OutputTransformations)
200 printResult(remapper&: migration.getRemapper(), OS&: llvm::outs());
201
202 // FIXME: TestResultForARC
203
204 return false;
205}
206
207static bool filesCompareEqual(StringRef fname1, StringRef fname2) {
208 using namespace llvm;
209
210 ErrorOr<std::unique_ptr<MemoryBuffer>> file1 =
211 MemoryBuffer::getFile(Filename: fname1, /*IsText=*/true);
212 if (!file1)
213 return false;
214
215 ErrorOr<std::unique_ptr<MemoryBuffer>> file2 =
216 MemoryBuffer::getFile(Filename: fname2, /*IsText=*/true);
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.ends_with(Suffix: ".result")) {
234 errs() << "error: filename '" << fname
235 << "' does not have '.result' extension\n";
236 return true;
237 }
238 resultMap[sys::path::stem(path: 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(Filename: RemappingsFile, /*IsText=*/true);
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(A&: strs, Separator: "\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(x: sys::path::filename(path: 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(Path: It->second)) {
277 errs() << "error: '" << It->second << "' does not exist\n";
278 return true;
279 }
280 if (!sys::fs::exists(Path: inputResultFname)) {
281 errs() << "error: '" << inputResultFname << "' does not exist\n";
282 return true;
283 }
284
285 if (!filesCompareEqual(fname1: It->second, fname2: inputResultFname)) {
286 errs() << "error: '" << It->second << "' is different than "
287 << "'" << inputResultFname << "'\n";
288 return true;
289 }
290
291 resultMap.erase(position: 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: loc);
312
313 OS << llvm::sys::path::filename(path: 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(Loc: range.getBegin());
324
325 OS << llvm::sys::path::filename(path: PL.getFilename());
326 OS << " [" << PL.getLine() << ":"
327 << PL.getColumn();
328 OS << " - ";
329
330 SourceLocation end = range.getEnd();
331 PL = SM.getPresumedLoc(Loc: end);
332
333 unsigned endCol = PL.getColumn() - 1;
334 if (!range.isTokenRange())
335 endCol += Lexer::MeasureTokenLength(Loc: end, SM, LangOpts: 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(Argv0: argv[0]);
346
347 std::string
348 resourcesPath = CompilerInvocation::GetResourcesPath(Argv0: 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(argc: optargc, argv, Overview: "arcmt-test");
356
357 if (VerifyTransformedFiles) {
358 if (ResultFiles.empty()) {
359 llvm::cl::PrintHelpMessage();
360 return 1;
361 }
362 return verifyTransformedFiles(resultFiles: 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