[clang-tooling] Prevent llvm::fatal_error on invalid CLI option
[lldb.git] / clang-tools-extra / clang-move / tool / ClangMove.cpp
1 //===-- ClangMove.cpp - move definition to new file -------------*- C++ -*-===//
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 "Move.h"
10 #include "clang/Frontend/TextDiagnosticPrinter.h"
11 #include "clang/Rewrite/Core/Rewriter.h"
12 #include "clang/Tooling/ArgumentsAdjusters.h"
13 #include "clang/Tooling/CommonOptionsParser.h"
14 #include "clang/Tooling/Refactoring.h"
15 #include "clang/Tooling/Tooling.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/Support/CommandLine.h"
18 #include "llvm/Support/Path.h"
19 #include "llvm/Support/Process.h"
20 #include "llvm/Support/Signals.h"
21 #include "llvm/Support/YAMLTraits.h"
22 #include <set>
23 #include <string>
24
25 using namespace clang;
26 using namespace llvm;
27
28 namespace {
29
30 std::error_code CreateNewFile(const llvm::Twine &path) {
31   int fd = 0;
32   if (std::error_code ec = llvm::sys::fs::openFileForWrite(
33           path, fd, llvm::sys::fs::CD_CreateAlways, llvm::sys::fs::OF_Text))
34     return ec;
35
36   return llvm::sys::Process::SafelyCloseFileDescriptor(fd);
37 }
38
39 cl::OptionCategory ClangMoveCategory("clang-move options");
40
41 cl::list<std::string> Names("names", cl::CommaSeparated,
42                             cl::desc("The list of the names of classes being "
43                                      "moved, e.g. \"Foo,a::Foo,b::Foo\"."),
44                             cl::cat(ClangMoveCategory));
45
46 cl::opt<std::string>
47     OldHeader("old_header",
48               cl::desc("The relative/absolute file path of old header."),
49               cl::cat(ClangMoveCategory));
50
51 cl::opt<std::string>
52     OldCC("old_cc", cl::desc("The relative/absolute file path of old cc."),
53           cl::cat(ClangMoveCategory));
54
55 cl::opt<std::string>
56     NewHeader("new_header",
57               cl::desc("The relative/absolute file path of new header."),
58               cl::cat(ClangMoveCategory));
59
60 cl::opt<std::string>
61     NewCC("new_cc", cl::desc("The relative/absolute file path of new cc."),
62           cl::cat(ClangMoveCategory));
63
64 cl::opt<bool>
65     OldDependOnNew("old_depend_on_new",
66                    cl::desc("Whether old header will depend on new header. If "
67                             "true, clang-move will "
68                             "add #include of new header to old header."),
69                    cl::init(false), cl::cat(ClangMoveCategory));
70
71 cl::opt<bool>
72     NewDependOnOld("new_depend_on_old",
73                    cl::desc("Whether new header will depend on old header. If "
74                             "true, clang-move will "
75                             "add #include of old header to new header."),
76                    cl::init(false), cl::cat(ClangMoveCategory));
77
78 cl::opt<std::string>
79     Style("style",
80           cl::desc("The style name used for reformatting. Default is \"llvm\""),
81           cl::init("llvm"), cl::cat(ClangMoveCategory));
82
83 cl::opt<bool> Dump("dump_result",
84                    cl::desc("Dump results in JSON format to stdout."),
85                    cl::cat(ClangMoveCategory));
86
87 cl::opt<bool> DumpDecls(
88     "dump_decls",
89     cl::desc("Dump all declarations in old header (JSON format) to stdout. If "
90              "the option is specified, other command options will be ignored. "
91              "An empty JSON will be returned if old header isn't specified."),
92     cl::cat(ClangMoveCategory));
93
94 } // namespace
95
96 int main(int argc, const char **argv) {
97   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
98   auto ExpectedParser =
99       tooling::CommonOptionsParser::create(argc, argv, ClangMoveCategory);
100   if (!ExpectedParser) {
101     llvm::errs() << ExpectedParser.takeError();
102     return 1;
103   }
104   tooling::CommonOptionsParser &OptionsParser = ExpectedParser.get();
105
106   if (OldDependOnNew && NewDependOnOld) {
107     llvm::errs() << "Provide either --old_depend_on_new or "
108                     "--new_depend_on_old. clang-move doesn't support these two "
109                     "options at same time (It will introduce include cycle).\n";
110     return 1;
111   }
112
113   tooling::RefactoringTool Tool(OptionsParser.getCompilations(),
114                                 OptionsParser.getSourcePathList());
115   // Add "-fparse-all-comments" compile option to make clang parse all comments.
116   Tool.appendArgumentsAdjuster(tooling::getInsertArgumentAdjuster(
117       "-fparse-all-comments", tooling::ArgumentInsertPosition::BEGIN));
118   move::MoveDefinitionSpec Spec;
119   Spec.Names = {Names.begin(), Names.end()};
120   Spec.OldHeader = OldHeader;
121   Spec.NewHeader = NewHeader;
122   Spec.OldCC = OldCC;
123   Spec.NewCC = NewCC;
124   Spec.OldDependOnNew = OldDependOnNew;
125   Spec.NewDependOnOld = NewDependOnOld;
126
127   llvm::SmallString<128> InitialDirectory;
128   if (std::error_code EC = llvm::sys::fs::current_path(InitialDirectory))
129     llvm::report_fatal_error("Cannot detect current path: " +
130                              Twine(EC.message()));
131
132   move::ClangMoveContext Context{Spec, Tool.getReplacements(),
133                                  std::string(InitialDirectory.str()), Style,
134                                  DumpDecls};
135   move::DeclarationReporter Reporter;
136   move::ClangMoveActionFactory Factory(&Context, &Reporter);
137
138   int CodeStatus = Tool.run(&Factory);
139   if (CodeStatus)
140     return CodeStatus;
141
142   if (DumpDecls) {
143     llvm::outs() << "[\n";
144     const auto &Declarations = Reporter.getDeclarationList();
145     for (auto I = Declarations.begin(), E = Declarations.end(); I != E; ++I) {
146       llvm::outs() << "  {\n";
147       llvm::outs() << "    \"DeclarationName\": \"" << I->QualifiedName
148                    << "\",\n";
149       llvm::outs() << "    \"DeclarationType\": \"" << I->Kind << "\",\n";
150       llvm::outs() << "    \"Templated\": " << (I->Templated ? "true" : "false")
151                    << "\n";
152       llvm::outs() << "  }";
153       // Don't print trailing "," at the end of last element.
154       if (I != std::prev(E))
155         llvm::outs() << ",\n";
156     }
157     llvm::outs() << "\n]\n";
158     return 0;
159   }
160
161   if (!NewCC.empty()) {
162     std::error_code EC = CreateNewFile(NewCC);
163     if (EC) {
164       llvm::errs() << "Failed to create " << NewCC << ": " << EC.message()
165                    << "\n";
166       return EC.value();
167     }
168   }
169   if (!NewHeader.empty()) {
170     std::error_code EC = CreateNewFile(NewHeader);
171     if (EC) {
172       llvm::errs() << "Failed to create " << NewHeader << ": " << EC.message()
173                    << "\n";
174       return EC.value();
175     }
176   }
177
178   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions());
179   clang::TextDiagnosticPrinter DiagnosticPrinter(errs(), &*DiagOpts);
180   DiagnosticsEngine Diagnostics(
181       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
182       &DiagnosticPrinter, false);
183   auto &FileMgr = Tool.getFiles();
184   SourceManager SM(Diagnostics, FileMgr);
185   Rewriter Rewrite(SM, LangOptions());
186
187   if (!formatAndApplyAllReplacements(Tool.getReplacements(), Rewrite, Style)) {
188     llvm::errs() << "Failed applying all replacements.\n";
189     return 1;
190   }
191
192   if (Dump) {
193     std::set<llvm::StringRef> Files;
194     for (const auto &it : Tool.getReplacements())
195       Files.insert(it.first);
196     auto WriteToJson = [&](llvm::raw_ostream &OS) {
197       OS << "[\n";
198       for (auto I = Files.begin(), E = Files.end(); I != E; ++I) {
199         OS << "  {\n";
200         OS << "    \"FilePath\": \"" << *I << "\",\n";
201         const auto Entry = FileMgr.getFile(*I);
202         auto ID = SM.translateFile(*Entry);
203         std::string Content;
204         llvm::raw_string_ostream ContentStream(Content);
205         Rewrite.getEditBuffer(ID).write(ContentStream);
206         OS << "    \"SourceText\": \""
207            << llvm::yaml::escape(ContentStream.str()) << "\"\n";
208         OS << "  }";
209         if (I != std::prev(E))
210           OS << ",\n";
211       }
212       OS << "\n]\n";
213     };
214     WriteToJson(llvm::outs());
215     return 0;
216   }
217
218   return Rewrite.overwriteChangedFiles();
219 }