contrib/llvm/tools/clang/lib/Frontend/Rewrite/FixItRewriter.cpp

   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
  28 using namespace clang;
  29
  30 FixItRewriter::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
  44 FixItRewriter::~FixItRewriter() {
  45   Diags.setClient(Client, Owner.release() != nullptr);
  46 }
  47
  48 bool 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
  56 namespace {
  57
  58 class RewritesReceiver : public edit::EditsReceiver {
  59   Rewriter &Rewrite;
  60
  61 public:
  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
  74 bool 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
 118 bool FixItRewriter::IncludeInDiagnosticCounts() const {
 119   return Client ? Client->IncludeInDiagnosticCounts() : true;
 120 }
 121
 122 void 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.
 193 void 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
 203 FixItOptions::~FixItOptions() {}