clang 17.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
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
35using 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
51bool 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
59namespace {
60
61class RewritesReceiver : public edit::EditsReceiver {
63
64public:
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).
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())
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.
199void 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
Defines the Diagnostic-related interfaces.
Defines the clang::FileManager interface and associated types.
StringRef Filename
Definition: Format.cpp:2774
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Represents a character-granular source range.
bool isTokenRange() const
Return true if the end of this range specifies the start of the last token.
SourceLocation getEnd() const
SourceLocation getBegin() const
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:564
virtual bool IncludeInDiagnosticCounts() const
Indicates whether the diagnostics handled by this DiagnosticConsumer should be included in the number...
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1566
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1577
unsigned getNumFixItHints() const
Definition: Diagnostic.h:1661
const FixItHint & getFixItHint(unsigned Idx) const
Definition: Diagnostic.h:1665
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1542
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)
Set the diagnostic client associated with this diagnostic object.
Definition: Diagnostic.cpp:112
void Clear()
Clear out the current diagnostic.
Definition: Diagnostic.h:977
std::unique_ptr< DiagnosticConsumer > takeClient()
Return the current diagnostic client along with ownership of that client.
Definition: Diagnostic.h:575
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:195
DiagnosticConsumer * getClient()
Definition: Diagnostic.h:567
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:353
StringRef getName() const
Definition: FileEntry.h:384
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:71
bool BeforePreviousInsertions
Definition: Diagnostic.h:85
CharSourceRange RemoveRange
Code that should be replaced to correct the error.
Definition: Diagnostic.h:75
CharSourceRange InsertFromRange
Code in the specific range that should be inserted in the insertion location.
Definition: Diagnostic.h:79
std::string CodeToInsert
The actual code to insert at the insertion location, as a string.
Definition: Diagnostic.h:83
virtual ~FixItOptions()
bool FixOnlyWarnings
Whether to only fix warnings and not errors.
Definition: FixItRewriter.h:54
bool FixWhatYouCan
Whether to abort fixing a file when not all errors could be fixed.
Definition: FixItRewriter.h:51
virtual std::string RewriteFilename(const std::string &Filename, int &fd)=0
This file is about to be rewritten.
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
bool InPlace
True if files should be updated in place.
Definition: FixItRewriter.h:48
Rewriter::buffer_iterator iterator
void Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic via the adapted diagnostic client.
bool WriteFixedFiles(std::vector< std::pair< std::string, std::string > > *RewrittenFiles=nullptr)
Write the modified source files.
bool WriteFixedFile(FileID ID, raw_ostream &OS)
Write a single modified source file.
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...
FixItRewriter(DiagnosticsEngine &Diags, SourceManager &SourceMgr, const LangOptions &LangOpts, FixItOptions *FixItOpts)
Initialize a new fix-it rewriter.
~FixItRewriter() override
Destroy the fix-it rewriter.
bool IncludeInDiagnosticCounts() const override
IncludeInDiagnosticCounts - This method (whose default implementation returns true) indicates whether...
A SourceLocation and its associated SourceManager.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:82
RewriteBuffer - As code is rewritten, SourceBuffer's from the original input with modifications get a...
Definition: RewriteBuffer.h:25
raw_ostream & write(raw_ostream &Stream) const
Write to Stream the result of applying all changes to the original buffer.
Definition: Rewriter.cpp:37
Rewriter - This is the main interface to the rewrite buffers.
Definition: Rewriter.h:32
const RewriteBuffer * getRewriteBufferFor(FileID FID) const
getRewriteBufferFor - Return the rewrite buffer for the specified FileID.
Definition: Rewriter.h:198
Encodes a location in the source.
This class handles loading and caching of source files into memory.
bool insertFromRange(SourceLocation loc, CharSourceRange range, bool afterToken=false, bool beforePreviousInsertions=false)
Definition: Commit.cpp:64
bool insert(SourceLocation loc, StringRef text, bool afterToken=false, bool beforePreviousInsertions=false)
Definition: Commit.cpp:48
bool isCommitable() const
Definition: Commit.h:68
bool remove(CharSourceRange range)
Definition: Commit.cpp:91
bool replace(CharSourceRange range, StringRef text)
Definition: Commit.cpp:116
void applyRewrites(EditsReceiver &receiver, bool adjustRemovals=true)
bool commit(const Commit &commit)
RangeSelector range(RangeSelector Begin, RangeSelector End)
DEPRECATED. Use enclose.
Definition: RangeSelector.h:41
@ Rewrite
We are substituting template parameters for (typically) other template parameters in order to rewrite...