1//===--- FixItRewriter.cpp - Fix-It Rewriter Diagnostic Client --*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This is a diagnostic client adaptor that performs rewrites as
11// suggested by code modification hints attached to diagnostics. It
12// then forwards any diagnostics to the adapted diagnostic client.
13//
14//===----------------------------------------------------------------------===//
15
16#include "clang/Rewrite/Frontend/FixItRewriter.h"
17#include "clang/Basic/FileManager.h"
18#include "clang/Basic/SourceLocation.h"
19#include "clang/Basic/SourceManager.h"
20#include "clang/Edit/Commit.h"
21#include "clang/Edit/EditsReceiver.h"
22#include "clang/Frontend/FrontendDiagnostic.h"
23#include "llvm/Support/Path.h"
24#include "llvm/Support/raw_ostream.h"
25#include <cstdio>
26#include <memory>
27
28using namespace clang;
29
30FixItRewriter::FixItRewriter(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
31                             const LangOptions &LangOpts,
32                             FixItOptions *FixItOpts)
33  : Diags(Diags),
34    Editor(SourceMgr, LangOpts),
35    Rewrite(SourceMgr, LangOpts),
36    FixItOpts(FixItOpts),
37    NumFailures(0),
38    PrevDiagSilenced(false) {
39  Owner = Diags.takeClient();
40  Client = Diags.getClient();
41  Diags.setClient(this, false);
42}
43
44FixItRewriter::~FixItRewriter() {
45  Diags.setClient(Client, Owner.release() != nullptr);
46}
47
48bool FixItRewriter::WriteFixedFile(FileID ID, raw_ostream &OS) {
49  const RewriteBuffer *RewriteBuf = Rewrite.getRewriteBufferFor(ID);
50  if (!RewriteBuf) return true;
51  RewriteBuf->write(OS);
52  OS.flush();
53  return false;
54}
55
56namespace {
57
58class RewritesReceiver : public edit::EditsReceiver {
59  Rewriter &Rewrite;
60
61public:
62  RewritesReceiver(Rewriter &Rewrite) : Rewrite(Rewrite) { }
63
64  void insert(SourceLocation loc, StringRef text) override {
65    Rewrite.InsertText(loc, text);
66  }
67  void replace(CharSourceRange range, StringRef text) override {
68    Rewrite.ReplaceText(range.getBegin(), Rewrite.getRangeSize(range), text);
69  }
70};
71
72}
73
74bool FixItRewriter::WriteFixedFiles(
75            std::vector<std::pair<std::string, std::string> > *RewrittenFiles) {
76  if (NumFailures > 0 && !FixItOpts->FixWhatYouCan) {
77    Diag(FullSourceLoc(), diag::warn_fixit_no_changes);
78    return true;
79  }
80
81  RewritesReceiver Rec(Rewrite);
82  Editor.applyRewrites(Rec);
83
84  if (FixItOpts->InPlace) {
85    // Overwriting open files on Windows is tricky, but the rewriter can do it
86    // for us.
87    Rewrite.overwriteChangedFiles();
88    return false;
89  }
90
91  for (iterator I = buffer_begin(), E = buffer_end(); I != E; ++I) {
92    const FileEntry *Entry = Rewrite.getSourceMgr().getFileEntryForID(I->first);
93    int fd;
94    std::string Filename = FixItOpts->RewriteFilename(Entry->getName(), fd);
95    std::error_code EC;
96    std::unique_ptr<llvm::raw_fd_ostream> OS;
97    if (fd != -1) {
98      OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
99    } else {
100      OS.reset(new llvm::raw_fd_ostream(Filename, EC, llvm::sys::fs::F_None));
101    }
102    if (EC) {
103      Diags.Report(clang::diag::err_fe_unable_to_open_output) << Filename
104                                                              << EC.message();
105      continue;
106    }
107    RewriteBuffer &RewriteBuf = I->second;
108    RewriteBuf.write(*OS);
109    OS->flush();
110
111    if (RewrittenFiles)
112      RewrittenFiles->push_back(std::make_pair(Entry->getName(), Filename));
113  }
114
115  return false;
116}
117
118bool FixItRewriter::IncludeInDiagnosticCounts() const {
119  return Client ? Client->IncludeInDiagnosticCounts() : true;
120}
121
122void FixItRewriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
123                                     const Diagnostic &Info) {
124  // Default implementation (Warnings/errors count).
125  DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
126
127  if (!FixItOpts->Silent ||
128      DiagLevel >= DiagnosticsEngine::Error ||
129      (DiagLevel == DiagnosticsEngine::Note && !PrevDiagSilenced) ||
130      (DiagLevel > DiagnosticsEngine::Note && Info.getNumFixItHints())) {
131    Client->HandleDiagnostic(DiagLevel, Info);
132    PrevDiagSilenced = false;
133  } else {
134    PrevDiagSilenced = true;
135  }
136
137  // Skip over any diagnostics that are ignored or notes.
138  if (DiagLevel <= DiagnosticsEngine::Note)
139    return;
140  // Skip over errors if we are only fixing warnings.
141  if (DiagLevel >= DiagnosticsEngine::Error && FixItOpts->FixOnlyWarnings) {
142    ++NumFailures;
143    return;
144  }
145
146  // Make sure that we can perform all of the modifications we
147  // in this diagnostic.
148  edit::Commit commit(Editor);
149  for (unsigned Idx = 0, Last = Info.getNumFixItHints();
150       Idx < Last; ++Idx) {
151    const FixItHint &Hint = Info.getFixItHint(Idx);
152
153    if (Hint.CodeToInsert.empty()) {
154      if (Hint.InsertFromRange.isValid())
155        commit.insertFromRange(Hint.RemoveRange.getBegin(),
156                           Hint.InsertFromRange, /*afterToken=*/false,
157                           Hint.BeforePreviousInsertions);
158      else
159        commit.remove(Hint.RemoveRange);
160    } else {
161      if (Hint.RemoveRange.isTokenRange() ||
162          Hint.RemoveRange.getBegin() != Hint.RemoveRange.getEnd())
163        commit.replace(Hint.RemoveRange, Hint.CodeToInsert);
164      else
165        commit.insert(Hint.RemoveRange.getBegin(), Hint.CodeToInsert,
166                    /*afterToken=*/false, Hint.BeforePreviousInsertions);
167    }
168  }
169  bool CanRewrite = Info.getNumFixItHints() > 0 && commit.isCommitable();
170
171  if (!CanRewrite) {
172    if (Info.getNumFixItHints() > 0)
173      Diag(Info.getLocation(), diag::note_fixit_in_macro);
174
175    // If this was an error, refuse to perform any rewriting.
176    if (DiagLevel >= DiagnosticsEngine::Error) {
177      if (++NumFailures == 1)
178        Diag(Info.getLocation(), diag::note_fixit_unfixed_error);
179    }
180    return;
181  }
182
183  if (!Editor.commit(commit)) {
184    ++NumFailures;
185    Diag(Info.getLocation(), diag::note_fixit_failed);
186    return;
187  }
188
189  Diag(Info.getLocation(), diag::note_fixit_applied);
190}
191
192/// \brief Emit a diagnostic via the adapted diagnostic client.
193void FixItRewriter::Diag(SourceLocation Loc, unsigned DiagID) {
194  // When producing this diagnostic, we temporarily bypass ourselves,
195  // clear out any current diagnostic, and let the downstream client
196  // format the diagnostic.
197  Diags.setClient(Client, false);
198  Diags.Clear();
199  Diags.Report(Loc, DiagID);
200  Diags.setClient(this, false);
201}
202
203FixItOptions::~FixItOptions() {}
204