1 //===--- AtomicChange.cpp - AtomicChange implementation -----------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "clang/Tooling/Refactoring/AtomicChange.h"
11 #include "clang/Tooling/ReplacementsYaml.h"
12 #include "llvm/Support/YAMLTraits.h"
15 LLVM_YAML_IS_SEQUENCE_VECTOR(clang::tooling::AtomicChange)
18 /// \brief Helper to (de)serialize an AtomicChange since we don't have direct
19 /// access to its data members.
20 /// Data members of a normalized AtomicChange can be directly mapped from/to
22 struct NormalizedAtomicChange {
23 NormalizedAtomicChange() = default;
25 NormalizedAtomicChange(const llvm::yaml::IO &) {}
27 // This converts AtomicChange's internal implementation of the replacements
28 // set to a vector of replacements.
29 NormalizedAtomicChange(const llvm::yaml::IO &,
30 const clang::tooling::AtomicChange &E)
31 : Key(E.getKey()), FilePath(E.getFilePath()), Error(E.getError()),
32 InsertedHeaders(E.getInsertedHeaders()),
33 RemovedHeaders(E.getRemovedHeaders()),
34 Replaces(E.getReplacements().begin(), E.getReplacements().end()) {}
36 // This is not expected to be called but needed for template instantiation.
37 clang::tooling::AtomicChange denormalize(const llvm::yaml::IO &) {
38 llvm_unreachable("Do not convert YAML to AtomicChange directly with '>>'. "
39 "Use AtomicChange::convertFromYAML instead.");
44 std::vector<std::string> InsertedHeaders;
45 std::vector<std::string> RemovedHeaders;
46 std::vector<clang::tooling::Replacement> Replaces;
48 } // anonymous namespace
53 /// \brief Specialized MappingTraits to describe how an AtomicChange is
55 template <> struct MappingTraits<NormalizedAtomicChange> {
56 static void mapping(IO &Io, NormalizedAtomicChange &Doc) {
57 Io.mapRequired("Key", Doc.Key);
58 Io.mapRequired("FilePath", Doc.FilePath);
59 Io.mapRequired("Error", Doc.Error);
60 Io.mapRequired("InsertedHeaders", Doc.InsertedHeaders);
61 Io.mapRequired("RemovedHeaders", Doc.RemovedHeaders);
62 Io.mapRequired("Replacements", Doc.Replaces);
66 /// \brief Specialized MappingTraits to describe how an AtomicChange is
68 template <> struct MappingTraits<clang::tooling::AtomicChange> {
69 static void mapping(IO &Io, clang::tooling::AtomicChange &Doc) {
70 MappingNormalization<NormalizedAtomicChange, clang::tooling::AtomicChange>
72 Io.mapRequired("Key", Keys->Key);
73 Io.mapRequired("FilePath", Keys->FilePath);
74 Io.mapRequired("Error", Keys->Error);
75 Io.mapRequired("InsertedHeaders", Keys->InsertedHeaders);
76 Io.mapRequired("RemovedHeaders", Keys->RemovedHeaders);
77 Io.mapRequired("Replacements", Keys->Replaces);
81 } // end namespace yaml
82 } // end namespace llvm
88 // Returns true if there is any line that violates \p ColumnLimit in range
90 bool violatesColumnLimit(llvm::StringRef Code, unsigned ColumnLimit,
91 unsigned Start, unsigned End) {
92 auto StartPos = Code.rfind('\n', Start);
93 StartPos = (StartPos == llvm::StringRef::npos) ? 0 : StartPos + 1;
95 auto EndPos = Code.find("\n", End);
96 if (EndPos == llvm::StringRef::npos)
99 llvm::SmallVector<llvm::StringRef, 8> Lines;
100 Code.substr(StartPos, EndPos - StartPos).split(Lines, '\n');
101 for (llvm::StringRef Line : Lines)
102 if (Line.size() > ColumnLimit)
108 getRangesForFormating(llvm::StringRef Code, unsigned ColumnLimit,
109 ApplyChangesSpec::FormatOption Format,
110 const clang::tooling::Replacements &Replaces) {
111 // kNone suppresses formatting entirely.
112 if (Format == ApplyChangesSpec::kNone)
114 std::vector<clang::tooling::Range> Ranges;
115 // This works assuming that replacements are ordered by offset.
116 // FIXME: use `getAffectedRanges()` to calculate when it does not include '\n'
117 // at the end of an insertion in affected ranges.
119 for (const clang::tooling::Replacement &R : Replaces) {
120 int Start = R.getOffset() + Offset;
121 int End = Start + R.getReplacementText().size();
122 if (!R.getReplacementText().empty() &&
123 R.getReplacementText().back() == '\n' && R.getLength() == 0 &&
124 R.getOffset() > 0 && R.getOffset() <= Code.size() &&
125 Code[R.getOffset() - 1] == '\n')
126 // If we are inserting at the start of a line and the replacement ends in
127 // a newline, we don't need to format the subsequent line.
129 Offset += R.getReplacementText().size() - R.getLength();
131 if (Format == ApplyChangesSpec::kAll ||
132 violatesColumnLimit(Code, ColumnLimit, Start, End))
133 Ranges.emplace_back(Start, End - Start);
138 inline llvm::Error make_string_error(const llvm::Twine &Message) {
139 return llvm::make_error<llvm::StringError>(Message,
140 llvm::inconvertibleErrorCode());
143 // Creates replacements for inserting/deleting #include headers.
144 llvm::Expected<Replacements>
145 createReplacementsForHeaders(llvm::StringRef FilePath, llvm::StringRef Code,
146 llvm::ArrayRef<AtomicChange> Changes,
147 const format::FormatStyle &Style) {
148 // Create header insertion/deletion replacements to be cleaned up
149 // (i.e. converted to real insertion/deletion replacements).
150 Replacements HeaderReplacements;
151 for (const auto &Change : Changes) {
152 for (llvm::StringRef Header : Change.getInsertedHeaders()) {
153 std::string EscapedHeader =
154 Header.startswith("<") || Header.startswith("\"")
156 : ("\"" + Header + "\"").str();
157 std::string ReplacementText = "#include " + EscapedHeader;
158 // Offset UINT_MAX and length 0 indicate that the replacement is a header
160 llvm::Error Err = HeaderReplacements.add(
161 tooling::Replacement(FilePath, UINT_MAX, 0, ReplacementText));
163 return std::move(Err);
165 for (const std::string &Header : Change.getRemovedHeaders()) {
166 // Offset UINT_MAX and length 1 indicate that the replacement is a header
169 HeaderReplacements.add(Replacement(FilePath, UINT_MAX, 1, Header));
171 return std::move(Err);
175 // cleanupAroundReplacements() converts header insertions/deletions into
176 // actual replacements that add/remove headers at the right location.
177 return clang::format::cleanupAroundReplacements(Code, HeaderReplacements,
181 // Combine replacements in all Changes as a `Replacements`. This ignores the
182 // file path in all replacements and replaces them with \p FilePath.
183 llvm::Expected<Replacements>
184 combineReplacementsInChanges(llvm::StringRef FilePath,
185 llvm::ArrayRef<AtomicChange> Changes) {
186 Replacements Replaces;
187 for (const auto &Change : Changes)
188 for (const auto &R : Change.getReplacements())
189 if (auto Err = Replaces.add(Replacement(
190 FilePath, R.getOffset(), R.getLength(), R.getReplacementText())))
191 return std::move(Err);
197 AtomicChange::AtomicChange(const SourceManager &SM,
198 SourceLocation KeyPosition) {
199 const FullSourceLoc FullKeyPosition(KeyPosition, SM);
200 std::pair<FileID, unsigned> FileIDAndOffset =
201 FullKeyPosition.getSpellingLoc().getDecomposedLoc();
202 const FileEntry *FE = SM.getFileEntryForID(FileIDAndOffset.first);
203 assert(FE && "Cannot create AtomicChange with invalid location.");
204 FilePath = FE->getName();
205 Key = FilePath + ":" + std::to_string(FileIDAndOffset.second);
208 AtomicChange::AtomicChange(std::string Key, std::string FilePath,
210 std::vector<std::string> InsertedHeaders,
211 std::vector<std::string> RemovedHeaders,
212 clang::tooling::Replacements Replaces)
213 : Key(std::move(Key)), FilePath(std::move(FilePath)),
214 Error(std::move(Error)), InsertedHeaders(std::move(InsertedHeaders)),
215 RemovedHeaders(std::move(RemovedHeaders)), Replaces(std::move(Replaces)) {
218 bool AtomicChange::operator==(const AtomicChange &Other) const {
219 if (Key != Other.Key || FilePath != Other.FilePath || Error != Other.Error)
221 if (!(Replaces == Other.Replaces))
223 // FXIME: Compare header insertions/removals.
227 std::string AtomicChange::toYAMLString() {
228 std::string YamlContent;
229 llvm::raw_string_ostream YamlContentStream(YamlContent);
231 llvm::yaml::Output YAML(YamlContentStream);
233 YamlContentStream.flush();
237 AtomicChange AtomicChange::convertFromYAML(llvm::StringRef YAMLContent) {
238 NormalizedAtomicChange NE;
239 llvm::yaml::Input YAML(YAMLContent);
241 AtomicChange E(NE.Key, NE.FilePath, NE.Error, NE.InsertedHeaders,
242 NE.RemovedHeaders, tooling::Replacements());
243 for (const auto &R : NE.Replaces) {
244 llvm::Error Err = E.Replaces.add(R);
247 "Failed to add replacement when Converting YAML to AtomicChange.");
248 llvm::consumeError(std::move(Err));
253 llvm::Error AtomicChange::replace(const SourceManager &SM,
254 const CharSourceRange &Range,
255 llvm::StringRef ReplacementText) {
256 return Replaces.add(Replacement(SM, Range, ReplacementText));
259 llvm::Error AtomicChange::replace(const SourceManager &SM, SourceLocation Loc,
260 unsigned Length, llvm::StringRef Text) {
261 return Replaces.add(Replacement(SM, Loc, Length, Text));
264 llvm::Error AtomicChange::insert(const SourceManager &SM, SourceLocation Loc,
265 llvm::StringRef Text, bool InsertAfter) {
267 return llvm::Error::success();
268 Replacement R(SM, Loc, 0, Text);
269 llvm::Error Err = Replaces.add(R);
271 return llvm::handleErrors(
272 std::move(Err), [&](const ReplacementError &RE) -> llvm::Error {
273 if (RE.get() != replacement_error::insert_conflict)
274 return llvm::make_error<ReplacementError>(RE);
275 unsigned NewOffset = Replaces.getShiftedCodePosition(R.getOffset());
278 RE.getExistingReplacement()->getReplacementText().size();
279 Replacement NewR(R.getFilePath(), NewOffset, 0, Text);
280 Replaces = Replaces.merge(Replacements(NewR));
281 return llvm::Error::success();
284 return llvm::Error::success();
287 void AtomicChange::addHeader(llvm::StringRef Header) {
288 InsertedHeaders.push_back(Header);
291 void AtomicChange::removeHeader(llvm::StringRef Header) {
292 RemovedHeaders.push_back(Header);
295 llvm::Expected<std::string>
296 applyAtomicChanges(llvm::StringRef FilePath, llvm::StringRef Code,
297 llvm::ArrayRef<AtomicChange> Changes,
298 const ApplyChangesSpec &Spec) {
299 llvm::Expected<Replacements> HeaderReplacements =
300 createReplacementsForHeaders(FilePath, Code, Changes, Spec.Style);
301 if (!HeaderReplacements)
302 return make_string_error(
303 "Failed to create replacements for header changes: " +
304 llvm::toString(HeaderReplacements.takeError()));
306 llvm::Expected<Replacements> Replaces =
307 combineReplacementsInChanges(FilePath, Changes);
309 return make_string_error("Failed to combine replacements in all changes: " +
310 llvm::toString(Replaces.takeError()));
312 Replacements AllReplaces = std::move(*Replaces);
313 for (const auto &R : *HeaderReplacements) {
314 llvm::Error Err = AllReplaces.add(R);
316 return make_string_error(
317 "Failed to combine existing replacements with header replacements: " +
318 llvm::toString(std::move(Err)));
322 llvm::Expected<Replacements> CleanReplaces =
323 format::cleanupAroundReplacements(Code, AllReplaces, Spec.Style);
325 return make_string_error("Failed to cleanup around replacements: " +
326 llvm::toString(CleanReplaces.takeError()));
327 AllReplaces = std::move(*CleanReplaces);
330 // Apply all replacements.
331 llvm::Expected<std::string> ChangedCode =
332 applyAllReplacements(Code, AllReplaces);
334 return make_string_error("Failed to apply all replacements: " +
335 llvm::toString(ChangedCode.takeError()));
337 // Sort inserted headers. This is done even if other formatting is turned off
338 // as incorrectly sorted headers are always just wrong, it's not a matter of
340 Replacements HeaderSortingReplacements = format::sortIncludes(
341 Spec.Style, *ChangedCode, AllReplaces.getAffectedRanges(), FilePath);
342 ChangedCode = applyAllReplacements(*ChangedCode, HeaderSortingReplacements);
344 return make_string_error(
345 "Failed to apply replacements for sorting includes: " +
346 llvm::toString(ChangedCode.takeError()));
348 AllReplaces = AllReplaces.merge(HeaderSortingReplacements);
350 std::vector<Range> FormatRanges = getRangesForFormating(
351 *ChangedCode, Spec.Style.ColumnLimit, Spec.Format, AllReplaces);
352 if (!FormatRanges.empty()) {
353 Replacements FormatReplacements =
354 format::reformat(Spec.Style, *ChangedCode, FormatRanges, FilePath);
355 ChangedCode = applyAllReplacements(*ChangedCode, FormatReplacements);
357 return make_string_error(
358 "Failed to apply replacements for formatting changed code: " +
359 llvm::toString(ChangedCode.takeError()));
364 } // end namespace tooling
365 } // end namespace clang