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
23 using namespace clang;
24 using namespace arcmt;
25
26 static llvm::cl::opt<bool>
27 CheckOnly("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
34 static llvm::cl::opt<bool>
35 OutputTransformations("output-transformations",
36 llvm::cl::desc("Print the source transformations"));
37
38 static llvm::cl::opt<bool>
39 VerifyDiags("verify",llvm::cl::desc("Verify emitted diagnostics and warnings"));
40
41 static llvm::cl::opt<bool>
42 VerboseOpt("v", llvm::cl::desc("Enable verbose output"));
43
44 static llvm::cl::opt<bool>
45 VerifyTransformedFiles("verify-transformed-files",
46 llvm::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
50 static llvm::cl::opt<std::string>
51 RemappingsFile("remappings-file",
52 llvm::cl::desc("Pairs of file mappings (typically the output of "
53 "c-arcmt-test)"));
54
55 static llvm::cl::list<std::string>
56 ResultFiles(llvm::cl::Positional, llvm::cl::desc("<filename>..."));
57
58 static 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).
GetExecutablePath(const char * Argv0)66 std::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
73 static void printSourceLocation(SourceLocation loc, ASTContext &Ctx,
74 raw_ostream &OS);
75 static void printSourceRange(CharSourceRange range, ASTContext &Ctx,
76 raw_ostream &OS);
77
78 namespace {
79
80 class PrintTransforms : public MigrationProcess::RewriteListener {
81 ASTContext *Ctx;
82 raw_ostream &OS;
83
84 public:
PrintTransforms(raw_ostream & OS)85 PrintTransforms(raw_ostream &OS)
86 : Ctx(nullptr), OS(OS) {}
87
start(ASTContext & ctx)88 void start(ASTContext &ctx) override { Ctx = &ctx; }
finish()89 void finish() override { Ctx = nullptr; }
90
insert(SourceLocation loc,StringRef text)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
remove(CharSourceRange range)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
checkForMigration(StringRef resourcesPath,ArrayRef<const char * > Args)108 static 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, *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
printResult(FileRemapper & remapper,raw_ostream & OS)141 static void printResult(FileRemapper &remapper, raw_ostream &OS) {
142 remapper.forEachMapping([](StringRef, StringRef) {},
143 [&](StringRef, const llvm::MemoryBufferRef &Buffer) {
144 OS << Buffer.getBuffer();
145 });
146 }
147
performTransformations(StringRef resourcesPath,ArrayRef<const char * > Args)148 static 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(origCI, Args, *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(origCI.getLangOpts()->getGC(),
178 origCI.getMigratorOpts().NoFinalizeRemoval);
179 assert(!transforms.empty());
180
181 std::unique_ptr<PrintTransforms> transformPrinter;
182 if (OutputTransformations)
183 transformPrinter.reset(new PrintTransforms(llvm::outs()));
184
185 for (unsigned i=0, e = transforms.size(); i != e; ++i) {
186 bool err = migration.applyTransform(transforms[i], 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(migration.getRemapper(), llvm::errs());
195 llvm::errs() << "\n##########################\n\n";
196 }
197 }
198
199 if (!OutputTransformations)
200 printResult(migration.getRemapper(), llvm::outs());
201
202 // FIXME: TestResultForARC
203
204 return false;
205 }
206
filesCompareEqual(StringRef fname1,StringRef fname2)207 static bool filesCompareEqual(StringRef fname1, StringRef fname2) {
208 using namespace llvm;
209
210 ErrorOr<std::unique_ptr<MemoryBuffer>> file1 =
211 MemoryBuffer::getFile(fname1, /*IsText=*/true);
212 if (!file1)
213 return false;
214
215 ErrorOr<std::unique_ptr<MemoryBuffer>> file2 =
216 MemoryBuffer::getFile(fname2, /*IsText=*/true);
217 if (!file2)
218 return false;
219
220 return file1.get()->getBuffer() == file2.get()->getBuffer();
221 }
222
verifyTransformedFiles(ArrayRef<std::string> resultFiles)223 static 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, /*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(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
printSourceLocation(SourceLocation loc,ASTContext & Ctx,raw_ostream & OS)308 static 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
printSourceRange(CharSourceRange range,ASTContext & Ctx,raw_ostream & OS)318 static 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
main(int argc,const char ** argv)343 int 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