From ea5c4a7ca3a85e50b6bd22c62b29d0cd58a99cfe Mon Sep 17 00:00:00 2001 From: Eric Liu Date: Tue, 28 Mar 2017 13:05:32 +0000 Subject: Added `applyAtomicChanges` function. Summary: ... which applies a set of `AtomicChange`s on code. Reviewers: klimek, djasper Reviewed By: djasper Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D30777 llvm-svn: 298913 --- clang/lib/Tooling/Refactoring/AtomicChange.cpp | 179 +++++++++++++++++++++++++ 1 file changed, 179 insertions(+) (limited to 'clang/lib/Tooling/Refactoring/AtomicChange.cpp') diff --git a/clang/lib/Tooling/Refactoring/AtomicChange.cpp b/clang/lib/Tooling/Refactoring/AtomicChange.cpp index 02c55100ffb..20c30ad5aec 100644 --- a/clang/lib/Tooling/Refactoring/AtomicChange.cpp +++ b/clang/lib/Tooling/Refactoring/AtomicChange.cpp @@ -84,6 +84,116 @@ template <> struct MappingTraits { namespace clang { namespace tooling { +namespace { + +// Returns true if there is any line that violates \p ColumnLimit in range +// [Start, End]. +bool violatesColumnLimit(llvm::StringRef Code, unsigned ColumnLimit, + unsigned Start, unsigned End) { + auto StartPos = Code.rfind('\n', Start); + StartPos = (StartPos == llvm::StringRef::npos) ? 0 : StartPos + 1; + + auto EndPos = Code.find("\n", End); + if (EndPos == llvm::StringRef::npos) + EndPos = Code.size(); + + llvm::SmallVector Lines; + Code.substr(StartPos, EndPos - StartPos).split(Lines, '\n'); + for (llvm::StringRef Line : Lines) + if (Line.size() > ColumnLimit) + return true; + return false; +} + +std::vector +getRangesForFormating(llvm::StringRef Code, unsigned ColumnLimit, + ApplyChangesSpec::FormatOption Format, + const clang::tooling::Replacements &Replaces) { + // kNone suppresses formatting entirely. + if (Format == ApplyChangesSpec::kNone) + return {}; + std::vector Ranges; + // This works assuming that replacements are ordered by offset. + // FIXME: use `getAffectedRanges()` to calculate when it does not include '\n' + // at the end of an insertion in affected ranges. + int Offset = 0; + for (const clang::tooling::Replacement &R : Replaces) { + int Start = R.getOffset() + Offset; + int End = Start + R.getReplacementText().size(); + if (!R.getReplacementText().empty() && + R.getReplacementText().back() == '\n' && R.getLength() == 0 && + R.getOffset() > 0 && R.getOffset() <= Code.size() && + Code[R.getOffset() - 1] == '\n') + // If we are inserting at the start of a line and the replacement ends in + // a newline, we don't need to format the subsequent line. + --End; + Offset += R.getReplacementText().size() - R.getLength(); + + if (Format == ApplyChangesSpec::kAll || + violatesColumnLimit(Code, ColumnLimit, Start, End)) + Ranges.emplace_back(Start, End - Start); + } + return Ranges; +} + +inline llvm::Error make_string_error(const llvm::Twine &Message) { + return llvm::make_error(Message, + llvm::inconvertibleErrorCode()); +} + +// Creates replacements for inserting/deleting #include headers. +llvm::Expected +createReplacementsForHeaders(llvm::StringRef FilePath, llvm::StringRef Code, + llvm::ArrayRef Changes, + const format::FormatStyle &Style) { + // Create header insertion/deletion replacements to be cleaned up + // (i.e. converted to real insertion/deletion replacements). + Replacements HeaderReplacements; + for (const auto &Change : Changes) { + for (llvm::StringRef Header : Change.getInsertedHeaders()) { + std::string EscapedHeader = + Header.startswith("<") || Header.startswith("\"") + ? Header.str() + : ("\"" + Header + "\"").str(); + std::string ReplacementText = "#include " + EscapedHeader; + // Offset UINT_MAX and length 0 indicate that the replacement is a header + // insertion. + llvm::Error Err = HeaderReplacements.add( + tooling::Replacement(FilePath, UINT_MAX, 0, ReplacementText)); + if (Err) + return std::move(Err); + } + for (const std::string &Header : Change.getRemovedHeaders()) { + // Offset UINT_MAX and length 1 indicate that the replacement is a header + // deletion. + llvm::Error Err = + HeaderReplacements.add(Replacement(FilePath, UINT_MAX, 1, Header)); + if (Err) + return std::move(Err); + } + } + + // cleanupAroundReplacements() converts header insertions/deletions into + // actual replacements that add/remove headers at the right location. + return clang::format::cleanupAroundReplacements(Code, HeaderReplacements, + Style); +} + +// Combine replacements in all Changes as a `Replacements`. This ignores the +// file path in all replacements and replaces them with \p FilePath. +llvm::Expected +combineReplacementsInChanges(llvm::StringRef FilePath, + llvm::ArrayRef Changes) { + Replacements Replaces; + for (const auto &Change : Changes) + for (const auto &R : Change.getReplacements()) + if (auto Err = Replaces.add(Replacement( + FilePath, R.getOffset(), R.getLength(), R.getReplacementText()))) + return std::move(Err); + return Replaces; +} + +} // end namespace AtomicChange::AtomicChange(const SourceManager &SM, SourceLocation KeyPosition) { @@ -168,5 +278,74 @@ void AtomicChange::removeHeader(llvm::StringRef Header) { RemovedHeaders.push_back(Header); } +llvm::Expected +applyAtomicChanges(llvm::StringRef FilePath, llvm::StringRef Code, + llvm::ArrayRef Changes, + const ApplyChangesSpec &Spec) { + llvm::Expected HeaderReplacements = + createReplacementsForHeaders(FilePath, Code, Changes, Spec.Style); + if (!HeaderReplacements) + return make_string_error( + "Failed to create replacements for header changes: " + + llvm::toString(HeaderReplacements.takeError())); + + llvm::Expected Replaces = + combineReplacementsInChanges(FilePath, Changes); + if (!Replaces) + return make_string_error("Failed to combine replacements in all changes: " + + llvm::toString(Replaces.takeError())); + + Replacements AllReplaces = std::move(*Replaces); + for (const auto &R : *HeaderReplacements) { + llvm::Error Err = AllReplaces.add(R); + if (Err) + return make_string_error( + "Failed to combine existing replacements with header replacements: " + + llvm::toString(std::move(Err))); + } + + if (Spec.Cleanup) { + llvm::Expected CleanReplaces = + format::cleanupAroundReplacements(Code, AllReplaces, Spec.Style); + if (!CleanReplaces) + return make_string_error("Failed to cleanup around replacements: " + + llvm::toString(CleanReplaces.takeError())); + AllReplaces = std::move(*CleanReplaces); + } + + // Apply all replacements. + llvm::Expected ChangedCode = + applyAllReplacements(Code, AllReplaces); + if (!ChangedCode) + return make_string_error("Failed to apply all replacements: " + + llvm::toString(ChangedCode.takeError())); + + // Sort inserted headers. This is done even if other formatting is turned off + // as incorrectly sorted headers are always just wrong, it's not a matter of + // taste. + Replacements HeaderSortingReplacements = format::sortIncludes( + Spec.Style, *ChangedCode, AllReplaces.getAffectedRanges(), FilePath); + ChangedCode = applyAllReplacements(*ChangedCode, HeaderSortingReplacements); + if (!ChangedCode) + return make_string_error( + "Failed to apply replacements for sorting includes: " + + llvm::toString(ChangedCode.takeError())); + + AllReplaces = AllReplaces.merge(HeaderSortingReplacements); + + std::vector FormatRanges = getRangesForFormating( + *ChangedCode, Spec.Style.ColumnLimit, Spec.Format, AllReplaces); + if (!FormatRanges.empty()) { + Replacements FormatReplacements = + format::reformat(Spec.Style, *ChangedCode, FormatRanges, FilePath); + ChangedCode = applyAllReplacements(*ChangedCode, FormatReplacements); + if (!ChangedCode) + return make_string_error( + "Failed to apply replacements for formatting changed code: " + + llvm::toString(ChangedCode.takeError())); + } + return ChangedCode; +} + } // end namespace tooling } // end namespace clang -- cgit v1.2.3