clang  13.0.0git
FixItRewriter.cpp
Go to the documentation of this file.
1 //===- FixItRewriter.cpp - Fix-It Rewriter Diagnostic Client --------------===//
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 // This is a diagnostic client adaptor that performs rewrites as
10 // suggested by code modification hints attached to diagnostics. It
11 // then forwards any diagnostics to the adapted diagnostic client.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "clang/Basic/Diagnostic.h"
18 #include "clang/Basic/LLVM.h"
21 #include "clang/Edit/Commit.h"
26 #include "llvm/ADT/StringRef.h"
27 #include "llvm/Support/FileSystem.h"
28 #include "llvm/Support/raw_ostream.h"
29 #include <cstdio>
30 #include <memory>
31 #include <string>
32 #include <system_error>
33 #include <utility>
34 
35 using namespace clang;
36 
38  const LangOptions &LangOpts,
39  FixItOptions *FixItOpts)
40  : Diags(Diags), Editor(SourceMgr, LangOpts), Rewrite(SourceMgr, LangOpts),
41  FixItOpts(FixItOpts) {
42  Owner = Diags.takeClient();
43  Client = Diags.getClient();
44  Diags.setClient(this, false);
45 }
46 
48  Diags.setClient(Client, Owner.release() != nullptr);
49 }
50 
51 bool FixItRewriter::WriteFixedFile(FileID ID, raw_ostream &OS) {
52  const RewriteBuffer *RewriteBuf = Rewrite.getRewriteBufferFor(ID);
53  if (!RewriteBuf) return true;
54  RewriteBuf->write(OS);
55  OS.flush();
56  return false;
57 }
58 
59 namespace {
60 
61 class RewritesReceiver : public edit::EditsReceiver {
63 
64 public:
65  RewritesReceiver(Rewriter &Rewrite) : Rewrite(Rewrite) {}
66 
67  void insert(SourceLocation loc, StringRef text) override {
68  Rewrite.InsertText(loc, text);
69  }
70 
71  void replace(CharSourceRange range, StringRef text) override {
72  Rewrite.ReplaceText(range.getBegin(), Rewrite.getRangeSize(range), text);
73  }
74 };
75 
76 } // namespace
77 
79  std::vector<std::pair<std::string, std::string>> *RewrittenFiles) {
80  if (NumFailures > 0 && !FixItOpts->FixWhatYouCan) {
81  Diag(FullSourceLoc(), diag::warn_fixit_no_changes);
82  return true;
83  }
84 
85  RewritesReceiver Rec(Rewrite);
86  Editor.applyRewrites(Rec);
87 
88  if (FixItOpts->InPlace) {
89  // Overwriting open files on Windows is tricky, but the rewriter can do it
90  // for us.
91  Rewrite.overwriteChangedFiles();
92  return false;
93  }
94 
95  for (iterator I = buffer_begin(), E = buffer_end(); I != E; ++I) {
96  const FileEntry *Entry = Rewrite.getSourceMgr().getFileEntryForID(I->first);
97  int fd;
98  std::string Filename =
99  FixItOpts->RewriteFilename(std::string(Entry->getName()), fd);
100  std::error_code EC;
101  std::unique_ptr<llvm::raw_fd_ostream> OS;
102  if (fd != -1) {
103  OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
104  } else {
105  OS.reset(new llvm::raw_fd_ostream(Filename, EC, llvm::sys::fs::OF_None));
106  }
107  if (EC) {
108  Diags.Report(clang::diag::err_fe_unable_to_open_output) << Filename
109  << EC.message();
110  continue;
111  }
112  RewriteBuffer &RewriteBuf = I->second;
113  RewriteBuf.write(*OS);
114  OS->flush();
115 
116  if (RewrittenFiles)
117  RewrittenFiles->push_back(
118  std::make_pair(std::string(Entry->getName()), Filename));
119  }
120 
121  return false;
122 }
123 
125  return Client ? Client->IncludeInDiagnosticCounts() : true;
126 }
127 
129  const Diagnostic &Info) {
130  // Default implementation (Warnings/errors count).
131  DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
132 
133  if (!FixItOpts->Silent ||
134  DiagLevel >= DiagnosticsEngine::Error ||
135  (DiagLevel == DiagnosticsEngine::Note && !PrevDiagSilenced) ||
136  (DiagLevel > DiagnosticsEngine::Note && Info.getNumFixItHints())) {
137  Client->HandleDiagnostic(DiagLevel, Info);
138  PrevDiagSilenced = false;
139  } else {
140  PrevDiagSilenced = true;
141  }
142 
143  // Skip over any diagnostics that are ignored or notes.
144  if (DiagLevel <= DiagnosticsEngine::Note)
145  return;
146  // Skip over errors if we are only fixing warnings.
147  if (DiagLevel >= DiagnosticsEngine::Error && FixItOpts->FixOnlyWarnings) {
148  ++NumFailures;
149  return;
150  }
151 
152  // Make sure that we can perform all of the modifications we
153  // in this diagnostic.
154  edit::Commit commit(Editor);
155  for (unsigned Idx = 0, Last = Info.getNumFixItHints();
156  Idx < Last; ++Idx) {
157  const FixItHint &Hint = Info.getFixItHint(Idx);
158 
159  if (Hint.CodeToInsert.empty()) {
160  if (Hint.InsertFromRange.isValid())
161  commit.insertFromRange(Hint.RemoveRange.getBegin(),
162  Hint.InsertFromRange, /*afterToken=*/false,
164  else
165  commit.remove(Hint.RemoveRange);
166  } else {
167  if (Hint.RemoveRange.isTokenRange() ||
168  Hint.RemoveRange.getBegin() != Hint.RemoveRange.getEnd())
169  commit.replace(Hint.RemoveRange, Hint.CodeToInsert);
170  else
171  commit.insert(Hint.RemoveRange.getBegin(), Hint.CodeToInsert,
172  /*afterToken=*/false, Hint.BeforePreviousInsertions);
173  }
174  }
175  bool CanRewrite = Info.getNumFixItHints() > 0 && commit.isCommitable();
176 
177  if (!CanRewrite) {
178  if (Info.getNumFixItHints() > 0)
179  Diag(Info.getLocation(), diag::note_fixit_in_macro);
180 
181  // If this was an error, refuse to perform any rewriting.
182  if (DiagLevel >= DiagnosticsEngine::Error) {
183  if (++NumFailures == 1)
184  Diag(Info.getLocation(), diag::note_fixit_unfixed_error);
185  }
186  return;
187  }
188 
189  if (!Editor.commit(commit)) {
190  ++NumFailures;
191  Diag(Info.getLocation(), diag::note_fixit_failed);
192  return;
193  }
194 
195  Diag(Info.getLocation(), diag::note_fixit_applied);
196 }
197 
198 /// Emit a diagnostic via the adapted diagnostic client.
199 void FixItRewriter::Diag(SourceLocation Loc, unsigned DiagID) {
200  // When producing this diagnostic, we temporarily bypass ourselves,
201  // clear out any current diagnostic, and let the downstream client
202  // format the diagnostic.
203  Diags.setClient(Client, false);
204  Diags.Clear();
205  Diags.Report(Loc, DiagID);
206  Diags.setClient(this, false);
207 }
208 
209 FixItOptions::~FixItOptions() = default;
clang::FixItRewriter::buffer_end
iterator buffer_end()
Definition: FixItRewriter.h:104
clang::Diagnostic::getNumFixItHints
unsigned getNumFixItHints() const
Definition: Diagnostic.h:1627
clang::DiagnosticsEngine::Level
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:194
clang::comments::tok::text
@ text
Definition: CommentLexer.h:35
clang::CharSourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:285
clang::FullSourceLoc
A SourceLocation and its associated SourceManager.
Definition: SourceLocation.h:366
clang::DiagnosticsEngine::setClient
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)
Set the diagnostic client associated with this diagnostic object.
Definition: Diagnostic.cpp:111
clang::FixItRewriter::~FixItRewriter
~FixItRewriter() override
Destroy the fix-it rewriter.
Definition: FixItRewriter.cpp:47
clang::FixItOptions::InPlace
bool InPlace
True if files should be updated in place.
Definition: FixItRewriter.h:48
clang::edit::Commit::insertFromRange
bool insertFromRange(SourceLocation loc, CharSourceRange range, bool afterToken=false, bool beforePreviousInsertions=false)
Definition: Commit.cpp:64
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:89
clang::FixItRewriter::WriteFixedFile
bool WriteFixedFile(FileID ID, raw_ostream &OS)
Write a single modified source file.
Definition: FixItRewriter.cpp:51
clang::edit::Commit::insert
bool insert(SourceLocation loc, StringRef text, bool afterToken=false, bool beforePreviousInsertions=false)
Definition: Commit.cpp:48
clang::FixItOptions::FixWhatYouCan
bool FixWhatYouCan
Whether to abort fixing a file when not all errors could be fixed.
Definition: FixItRewriter.h:51
clang::RewriteBuffer::write
raw_ostream & write(raw_ostream &Stream) const
Write to Stream the result of applying all changes to the original buffer.
Definition: Rewriter.cpp:37
clang::edit::Commit::replace
bool replace(CharSourceRange range, StringRef text)
Definition: Commit.cpp:116
clang::TemplateSubstitutionKind::Rewrite
@ Rewrite
We are substituting template parameters for (typically) other template parameters in order to rewrite...
clang::FixItRewriter::IncludeInDiagnosticCounts
bool IncludeInDiagnosticCounts() const override
IncludeInDiagnosticCounts - This method (whose default implementation returns true) indicates whether...
Definition: FixItRewriter.cpp:124
Filename
StringRef Filename
Definition: Format.cpp:2145
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:191
SourceManager.h
clang::FixItRewriter::buffer_begin
iterator buffer_begin()
Definition: FixItRewriter.h:103
EditsReceiver.h
clang::edit::EditedSource::applyRewrites
void applyRewrites(EditsReceiver &receiver, bool adjustRemovals=true)
Definition: EditedSource.cpp:409
clang::edit::EditsReceiver
Definition: EditsReceiver.h:19
clang::FixItOptions::FixOnlyWarnings
bool FixOnlyWarnings
Whether to only fix warnings and not errors.
Definition: FixItRewriter.h:54
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:624
clang::FixItHint
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:70
clang::Diagnostic
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1532
clang::DiagnosticConsumer::HandleDiagnostic
virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info)
Handle this diagnostic, reporting it to the user or capturing it to a log as needed.
Definition: Diagnostic.cpp:547
clang::DiagnosticsEngine::takeClient
std::unique_ptr< DiagnosticConsumer > takeClient()
Return the current diagnostic client along with ownership of that client.
Definition: Diagnostic.h:573
clang::DiagnosticsEngine::Clear
void Clear()
Clear out the current diagnostic.
Definition: Diagnostic.h:972
Diagnostic.h
clang::DiagnosticsEngine::Error
@ Error
Definition: Diagnostic.h:199
clang::FixItHint::BeforePreviousInsertions
bool BeforePreviousInsertions
Definition: Diagnostic.h:84
clang::DiagnosticsEngine::getClient
DiagnosticConsumer * getClient()
Definition: Diagnostic.h:565
clang::FixItOptions::Silent
bool Silent
If true, only pass the diagnostic to the actual diagnostic consumer if it is an error or a fixit was ...
Definition: FixItRewriter.h:59
FixItRewriter.h
clang::FixItHint::InsertFromRange
CharSourceRange InsertFromRange
Code in the specific range that should be inserted in the insertion location.
Definition: Diagnostic.h:78
clang::DiagnosticConsumer::IncludeInDiagnosticCounts
virtual bool IncludeInDiagnosticCounts() const
Indicates whether the diagnostics handled by this DiagnosticConsumer should be included in the number...
Definition: Diagnostic.cpp:1131
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:331
SourceLocation.h
clang::FixItHint::CodeToInsert
std::string CodeToInsert
The actual code to insert at the insertion location, as a string.
Definition: Diagnostic.h:82
clang::edit::Commit
Definition: Commit.h:29
clang::CharSourceRange::isTokenRange
bool isTokenRange() const
Return true if the end of this range specifies the start of the last token.
Definition: SourceLocation.h:282
clang::Diagnostic::getLocation
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1543
clang::Diagnostic::getFixItHint
const FixItHint & getFixItHint(unsigned Idx) const
Definition: Diagnostic.h:1631
clang::CharSourceRange
Represents a character-granular source range.
Definition: SourceLocation.h:255
clang::FixItOptions::~FixItOptions
virtual ~FixItOptions()
LLVM.h
Commit.h
clang::CharSourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:286
clang::edit::EditedSource::commit
bool commit(const Commit &commit)
Definition: EditedSource.cpp:276
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:58
clang::FixItOptions::RewriteFilename
virtual std::string RewriteFilename(const std::string &Filename, int &fd)=0
This file is about to be rewritten.
clang::Rewriter::getRewriteBufferFor
const RewriteBuffer * getRewriteBufferFor(FileID FID) const
getRewriteBufferFor - Return the rewrite buffer for the specified FileID.
Definition: Rewriter.h:198
clang::FixItRewriter::iterator
Rewriter::buffer_iterator iterator
Definition: FixItRewriter.h:100
clang::CharSourceRange::isValid
bool isValid() const
Definition: SourceLocation.h:293
clang::Builtin::ID
ID
Definition: Builtins.h:46
clang
Dataflow Directional Tag Classes.
Definition: CalledOnceCheck.h:17
clang::RewriteBuffer
RewriteBuffer - As code is rewritten, SourceBuffer's from the original input with modifications get a...
Definition: RewriteBuffer.h:25
clang::transformer::range
RangeSelector range(RangeSelector Begin, RangeSelector End)
DEPRECATED. Use enclose.
Definition: RangeSelector.h:41
FrontendDiagnostic.h
clang::ComparisonCategoryType::Last
@ Last
clang::edit::Commit::isCommitable
bool isCommitable() const
Definition: Commit.h:68
clang::FixItRewriter::Diag
void Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic via the adapted diagnostic client.
Definition: FixItRewriter.cpp:199
clang::FileEntry::getName
StringRef getName() const
Definition: FileEntry.h:364
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:41
clang::Rewriter
Rewriter - This is the main interface to the rewrite buffers.
Definition: Rewriter.h:32
RewriteBuffer.h
clang::FixItRewriter::FixItRewriter
FixItRewriter(DiagnosticsEngine &Diags, SourceManager &SourceMgr, const LangOptions &LangOpts, FixItOptions *FixItOpts)
Initialize a new fix-it rewriter.
Definition: FixItRewriter.cpp:37
clang::FixItHint::RemoveRange
CharSourceRange RemoveRange
Code that should be replaced to correct the error.
Definition: Diagnostic.h:74
clang::DiagnosticsEngine::Note
@ Note
Definition: Diagnostic.h:196
clang::FixItOptions
Definition: FixItRewriter.h:33
Rewriter.h
FileManager.h
clang::FixItRewriter::WriteFixedFiles
bool WriteFixedFiles(std::vector< std::pair< std::string, std::string >> *RewrittenFiles=nullptr)
Write the modified source files.
Definition: FixItRewriter.cpp:78
clang::edit::Commit::remove
bool remove(CharSourceRange range)
Definition: Commit.cpp:91
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1508
clang::FixItRewriter::HandleDiagnostic
void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) override
HandleDiagnostic - Handle this diagnostic, reporting it to the user or capturing it to a log as neede...
Definition: FixItRewriter.cpp:128