head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.5 netbsd-11-0-RC3:1.1.1.5 netbsd-11-0-RC2:1.1.1.5 netbsd-11-0-RC1:1.1.1.5 perseant-exfatfs-base-20250801:1.1.1.5 netbsd-11:1.1.1.5.0.10 netbsd-11-base:1.1.1.5 netbsd-10-1-RELEASE:1.1.1.5 perseant-exfatfs-base-20240630:1.1.1.5 perseant-exfatfs:1.1.1.5.0.8 perseant-exfatfs-base:1.1.1.5 netbsd-8-3-RELEASE:1.1.1.3 netbsd-9-4-RELEASE:1.1.1.4 netbsd-10-0-RELEASE:1.1.1.5 netbsd-10-0-RC6:1.1.1.5 netbsd-10-0-RC5:1.1.1.5 netbsd-10-0-RC4:1.1.1.5 netbsd-10-0-RC3:1.1.1.5 netbsd-10-0-RC2:1.1.1.5 netbsd-10-0-RC1:1.1.1.5 netbsd-10:1.1.1.5.0.6 netbsd-10-base:1.1.1.5 netbsd-9-3-RELEASE:1.1.1.4 cjep_sun2x:1.1.1.5.0.4 cjep_sun2x-base:1.1.1.5 cjep_staticlib_x-base1:1.1.1.5 netbsd-9-2-RELEASE:1.1.1.4 cjep_staticlib_x:1.1.1.5.0.2 cjep_staticlib_x-base:1.1.1.5 netbsd-9-1-RELEASE:1.1.1.4 phil-wifi-20200421:1.1.1.5 phil-wifi-20200411:1.1.1.5 phil-wifi-20200406:1.1.1.5 netbsd-8-2-RELEASE:1.1.1.3 netbsd-9-0-RELEASE:1.1.1.4 netbsd-9-0-RC2:1.1.1.4 netbsd-9-0-RC1:1.1.1.4 netbsd-9:1.1.1.4.0.2 netbsd-9-base:1.1.1.4 phil-wifi-20190609:1.1.1.4 netbsd-8-1-RELEASE:1.1.1.3 netbsd-8-1-RC1:1.1.1.3 pgoyette-compat-merge-20190127:1.1.1.3.12.1 pgoyette-compat-20190127:1.1.1.4 pgoyette-compat-20190118:1.1.1.4 pgoyette-compat-1226:1.1.1.4 pgoyette-compat-1126:1.1.1.4 pgoyette-compat-1020:1.1.1.4 pgoyette-compat-0930:1.1.1.4 pgoyette-compat-0906:1.1.1.4 netbsd-7-2-RELEASE:1.1.1.1.2.2 pgoyette-compat-0728:1.1.1.4 clang-337282:1.1.1.4 netbsd-8-0-RELEASE:1.1.1.3 phil-wifi:1.1.1.3.0.14 phil-wifi-base:1.1.1.3 pgoyette-compat-0625:1.1.1.3 netbsd-8-0-RC2:1.1.1.3 pgoyette-compat-0521:1.1.1.3 pgoyette-compat-0502:1.1.1.3 pgoyette-compat-0422:1.1.1.3 netbsd-8-0-RC1:1.1.1.3 pgoyette-compat-0415:1.1.1.3 pgoyette-compat-0407:1.1.1.3 pgoyette-compat-0330:1.1.1.3 pgoyette-compat-0322:1.1.1.3 pgoyette-compat-0315:1.1.1.3 netbsd-7-1-2-RELEASE:1.1.1.1.2.2 pgoyette-compat:1.1.1.3.0.12 pgoyette-compat-base:1.1.1.3 netbsd-7-1-1-RELEASE:1.1.1.1.2.2 clang-319952:1.1.1.3 matt-nb8-mediatek:1.1.1.3.0.10 matt-nb8-mediatek-base:1.1.1.3 clang-309604:1.1.1.3 perseant-stdc-iso10646:1.1.1.3.0.8 perseant-stdc-iso10646-base:1.1.1.3 netbsd-8:1.1.1.3.0.6 netbsd-8-base:1.1.1.3 prg-localcount2-base3:1.1.1.3 prg-localcount2-base2:1.1.1.3 prg-localcount2-base1:1.1.1.3 prg-localcount2:1.1.1.3.0.4 prg-localcount2-base:1.1.1.3 pgoyette-localcount-20170426:1.1.1.3 bouyer-socketcan-base1:1.1.1.3 pgoyette-localcount-20170320:1.1.1.3 netbsd-7-1:1.1.1.1.2.2.0.6 netbsd-7-1-RELEASE:1.1.1.1.2.2 netbsd-7-1-RC2:1.1.1.1.2.2 clang-294123:1.1.1.3 netbsd-7-nhusb-base-20170116:1.1.1.1.2.2 bouyer-socketcan:1.1.1.3.0.2 bouyer-socketcan-base:1.1.1.3 clang-291444:1.1.1.3 pgoyette-localcount-20170107:1.1.1.2 netbsd-7-1-RC1:1.1.1.1.2.2 pgoyette-localcount-20161104:1.1.1.2 netbsd-7-0-2-RELEASE:1.1.1.1.2.2 localcount-20160914:1.1.1.2 netbsd-7-nhusb:1.1.1.1.2.2.0.4 netbsd-7-nhusb-base:1.1.1.1.2.2 clang-280599:1.1.1.2 pgoyette-localcount-20160806:1.1.1.2 pgoyette-localcount-20160726:1.1.1.2 pgoyette-localcount:1.1.1.2.0.2 pgoyette-localcount-base:1.1.1.2 netbsd-7-0-1-RELEASE:1.1.1.1.2.2 clang-261930:1.1.1.2 netbsd-7-0:1.1.1.1.2.2.0.2 netbsd-7-0-RELEASE:1.1.1.1.2.2 netbsd-7-0-RC3:1.1.1.1.2.2 netbsd-7-0-RC2:1.1.1.1.2.2 netbsd-7-0-RC1:1.1.1.1.2.2 netbsd-7:1.1.1.1.0.2 clang-237755:1.1.1.1 clang-232565:1.1.1.1 clang-227398:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2015.01.29.19.57.32; author joerg; state Exp; branches 1.1.1.1; next ; commitid mlISSizlPKvepX7y; 1.1.1.1 date 2015.01.29.19.57.32; author joerg; state Exp; branches 1.1.1.1.2.1; next 1.1.1.2; commitid mlISSizlPKvepX7y; 1.1.1.2 date 2016.02.27.22.11.49; author joerg; state Exp; branches 1.1.1.2.2.1; next 1.1.1.3; commitid tIimz3oDlh1NpBWy; 1.1.1.3 date 2017.01.11.10.35.43; author joerg; state Exp; branches 1.1.1.3.12.1 1.1.1.3.14.1; next 1.1.1.4; commitid CNnUNfII1jgNmxBz; 1.1.1.4 date 2018.07.17.18.31.14; author joerg; state Exp; branches; next 1.1.1.5; commitid wDzL46ALjrCZgwKA; 1.1.1.5 date 2019.11.13.22.19.29; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.1.2.1 date 2015.01.29.19.57.32; author snj; state dead; branches; next 1.1.1.1.2.2; commitid yRnjq9fueSo6n9oy; 1.1.1.1.2.2 date 2015.06.04.20.04.31; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.2.2.1 date 2017.03.20.06.52.42; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.3.12.1 date 2018.07.28.04.33.25; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.3.14.1 date 2019.06.10.21.45.30; author christos; state Exp; branches; next 1.1.1.3.14.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.3.14.2 date 2020.04.13.07.46.40; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- Replacement.cpp - Framework for clang refactoring tools ----------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Implements classes to support/store refactorings. // //===----------------------------------------------------------------------===// #include "clang/Basic/Diagnostic.h" #include "clang/Basic/DiagnosticIDs.h" #include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/Lexer.h" #include "clang/Rewrite/Core/Rewriter.h" #include "clang/Tooling/Core/Replacement.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_os_ostream.h" namespace clang { namespace tooling { static const char * const InvalidLocation = ""; Replacement::Replacement() : FilePath(InvalidLocation) {} Replacement::Replacement(StringRef FilePath, unsigned Offset, unsigned Length, StringRef ReplacementText) : FilePath(FilePath), ReplacementRange(Offset, Length), ReplacementText(ReplacementText) {} Replacement::Replacement(const SourceManager &Sources, SourceLocation Start, unsigned Length, StringRef ReplacementText) { setFromSourceLocation(Sources, Start, Length, ReplacementText); } Replacement::Replacement(const SourceManager &Sources, const CharSourceRange &Range, StringRef ReplacementText) { setFromSourceRange(Sources, Range, ReplacementText); } bool Replacement::isApplicable() const { return FilePath != InvalidLocation; } bool Replacement::apply(Rewriter &Rewrite) const { SourceManager &SM = Rewrite.getSourceMgr(); const FileEntry *Entry = SM.getFileManager().getFile(FilePath); if (!Entry) return false; FileID ID; // FIXME: Use SM.translateFile directly. SourceLocation Location = SM.translateFileLineCol(Entry, 1, 1); ID = Location.isValid() ? SM.getFileID(Location) : SM.createFileID(Entry, SourceLocation(), SrcMgr::C_User); // FIXME: We cannot check whether Offset + Length is in the file, as // the remapping API is not public in the RewriteBuffer. const SourceLocation Start = SM.getLocForStartOfFile(ID). getLocWithOffset(ReplacementRange.getOffset()); // ReplaceText returns false on success. // ReplaceText only fails if the source location is not a file location, in // which case we already returned false earlier. bool RewriteSucceeded = !Rewrite.ReplaceText( Start, ReplacementRange.getLength(), ReplacementText); assert(RewriteSucceeded); return RewriteSucceeded; } std::string Replacement::toString() const { std::string result; llvm::raw_string_ostream stream(result); stream << FilePath << ": " << ReplacementRange.getOffset() << ":+" << ReplacementRange.getLength() << ":\"" << ReplacementText << "\""; return result; } bool operator<(const Replacement &LHS, const Replacement &RHS) { if (LHS.getOffset() != RHS.getOffset()) return LHS.getOffset() < RHS.getOffset(); if (LHS.getLength() != RHS.getLength()) return LHS.getLength() < RHS.getLength(); if (LHS.getFilePath() != RHS.getFilePath()) return LHS.getFilePath() < RHS.getFilePath(); return LHS.getReplacementText() < RHS.getReplacementText(); } bool operator==(const Replacement &LHS, const Replacement &RHS) { return LHS.getOffset() == RHS.getOffset() && LHS.getLength() == RHS.getLength() && LHS.getFilePath() == RHS.getFilePath() && LHS.getReplacementText() == RHS.getReplacementText(); } void Replacement::setFromSourceLocation(const SourceManager &Sources, SourceLocation Start, unsigned Length, StringRef ReplacementText) { const std::pair DecomposedLocation = Sources.getDecomposedLoc(Start); const FileEntry *Entry = Sources.getFileEntryForID(DecomposedLocation.first); if (Entry) { // Make FilePath absolute so replacements can be applied correctly when // relative paths for files are used. llvm::SmallString<256> FilePath(Entry->getName()); std::error_code EC = llvm::sys::fs::make_absolute(FilePath); this->FilePath = EC ? FilePath.c_str() : Entry->getName(); } else { this->FilePath = InvalidLocation; } this->ReplacementRange = Range(DecomposedLocation.second, Length); this->ReplacementText = ReplacementText; } // FIXME: This should go into the Lexer, but we need to figure out how // to handle ranges for refactoring in general first - there is no obvious // good way how to integrate this into the Lexer yet. static int getRangeSize(const SourceManager &Sources, const CharSourceRange &Range) { SourceLocation SpellingBegin = Sources.getSpellingLoc(Range.getBegin()); SourceLocation SpellingEnd = Sources.getSpellingLoc(Range.getEnd()); std::pair Start = Sources.getDecomposedLoc(SpellingBegin); std::pair End = Sources.getDecomposedLoc(SpellingEnd); if (Start.first != End.first) return -1; if (Range.isTokenRange()) End.second += Lexer::MeasureTokenLength(SpellingEnd, Sources, LangOptions()); return End.second - Start.second; } void Replacement::setFromSourceRange(const SourceManager &Sources, const CharSourceRange &Range, StringRef ReplacementText) { setFromSourceLocation(Sources, Sources.getSpellingLoc(Range.getBegin()), getRangeSize(Sources, Range), ReplacementText); } unsigned shiftedCodePosition(const Replacements &Replaces, unsigned Position) { unsigned NewPosition = Position; for (Replacements::iterator I = Replaces.begin(), E = Replaces.end(); I != E; ++I) { if (I->getOffset() >= Position) break; if (I->getOffset() + I->getLength() > Position) NewPosition += I->getOffset() + I->getLength() - Position; NewPosition += I->getReplacementText().size() - I->getLength(); } return NewPosition; } // FIXME: Remove this function when Replacements is implemented as std::vector // instead of std::set. unsigned shiftedCodePosition(const std::vector &Replaces, unsigned Position) { unsigned NewPosition = Position; for (std::vector::const_iterator I = Replaces.begin(), E = Replaces.end(); I != E; ++I) { if (I->getOffset() >= Position) break; if (I->getOffset() + I->getLength() > Position) NewPosition += I->getOffset() + I->getLength() - Position; NewPosition += I->getReplacementText().size() - I->getLength(); } return NewPosition; } void deduplicate(std::vector &Replaces, std::vector &Conflicts) { if (Replaces.empty()) return; auto LessNoPath = [](const Replacement &LHS, const Replacement &RHS) { if (LHS.getOffset() != RHS.getOffset()) return LHS.getOffset() < RHS.getOffset(); if (LHS.getLength() != RHS.getLength()) return LHS.getLength() < RHS.getLength(); return LHS.getReplacementText() < RHS.getReplacementText(); }; auto EqualNoPath = [](const Replacement &LHS, const Replacement &RHS) { return LHS.getOffset() == RHS.getOffset() && LHS.getLength() == RHS.getLength() && LHS.getReplacementText() == RHS.getReplacementText(); }; // Deduplicate. We don't want to deduplicate based on the path as we assume // that all replacements refer to the same file (or are symlinks). std::sort(Replaces.begin(), Replaces.end(), LessNoPath); Replaces.erase(std::unique(Replaces.begin(), Replaces.end(), EqualNoPath), Replaces.end()); // Detect conflicts Range ConflictRange(Replaces.front().getOffset(), Replaces.front().getLength()); unsigned ConflictStart = 0; unsigned ConflictLength = 1; for (unsigned i = 1; i < Replaces.size(); ++i) { Range Current(Replaces[i].getOffset(), Replaces[i].getLength()); if (ConflictRange.overlapsWith(Current)) { // Extend conflicted range ConflictRange = Range(ConflictRange.getOffset(), std::max(ConflictRange.getLength(), Current.getOffset() + Current.getLength() - ConflictRange.getOffset())); ++ConflictLength; } else { if (ConflictLength > 1) Conflicts.push_back(Range(ConflictStart, ConflictLength)); ConflictRange = Current; ConflictStart = i; ConflictLength = 1; } } if (ConflictLength > 1) Conflicts.push_back(Range(ConflictStart, ConflictLength)); } bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite) { bool Result = true; for (Replacements::const_iterator I = Replaces.begin(), E = Replaces.end(); I != E; ++I) { if (I->isApplicable()) { Result = I->apply(Rewrite) && Result; } else { Result = false; } } return Result; } // FIXME: Remove this function when Replacements is implemented as std::vector // instead of std::set. bool applyAllReplacements(const std::vector &Replaces, Rewriter &Rewrite) { bool Result = true; for (std::vector::const_iterator I = Replaces.begin(), E = Replaces.end(); I != E; ++I) { if (I->isApplicable()) { Result = I->apply(Rewrite) && Result; } else { Result = false; } } return Result; } std::string applyAllReplacements(StringRef Code, const Replacements &Replaces) { FileManager Files((FileSystemOptions())); DiagnosticsEngine Diagnostics( IntrusiveRefCntPtr(new DiagnosticIDs), new DiagnosticOptions); SourceManager SourceMgr(Diagnostics, Files); Rewriter Rewrite(SourceMgr, LangOptions()); std::unique_ptr Buf = llvm::MemoryBuffer::getMemBuffer(Code, ""); const clang::FileEntry *Entry = Files.getVirtualFile("", Buf->getBufferSize(), 0); SourceMgr.overrideFileContents(Entry, std::move(Buf)); FileID ID = SourceMgr.createFileID(Entry, SourceLocation(), clang::SrcMgr::C_User); for (Replacements::const_iterator I = Replaces.begin(), E = Replaces.end(); I != E; ++I) { Replacement Replace("", I->getOffset(), I->getLength(), I->getReplacementText()); if (!Replace.apply(Rewrite)) return ""; } std::string Result; llvm::raw_string_ostream OS(Result); Rewrite.getEditBuffer(ID).write(OS); OS.flush(); return Result; } } // end namespace tooling } // end namespace clang @ 1.1.1.1 log @Import Clang 3.6RC1 r227398. @ text @@ 1.1.1.2 log @Import Clang 3.8.0rc3 r261930. @ text @d46 2 a47 3 StringRef ReplacementText, const LangOptions &LangOpts) { setFromSourceRange(Sources, Range, ReplacementText, LangOpts); d80 3 a82 3 std::string Result; llvm::raw_string_ostream Stream(Result); Stream << FilePath << ": " << ReplacementRange.getOffset() << ":+" d84 1 a84 1 return Stream.str(); a89 4 // Apply longer replacements first, specifically so that deletions are // executed before insertions. It is (hopefully) never the intention to // delete parts of newly inserted code. d91 1 a91 2 return LHS.getLength() > RHS.getLength(); d110 9 a118 1 this->FilePath = Entry ? Entry->getName() : InvalidLocation; d127 1 a127 2 const CharSourceRange &Range, const LangOptions &LangOpts) { d134 2 a135 1 End.second += Lexer::MeasureTokenLength(SpellingEnd, Sources, LangOpts); d141 1 a141 2 StringRef ReplacementText, const LangOptions &LangOpts) { d143 1 a143 2 getRangeSize(Sources, Range, LangOpts), ReplacementText); d146 9 a154 13 template unsigned shiftedCodePositionInternal(const T &Replaces, unsigned Position) { unsigned Offset = 0; for (const auto& R : Replaces) { if (R.getOffset() + R.getLength() <= Position) { Offset += R.getReplacementText().size() - R.getLength(); continue; } if (R.getOffset() < Position && R.getOffset() + R.getReplacementText().size() <= Position) { Position = R.getOffset() + R.getReplacementText().size() - 1; } break; d156 1 a156 5 return Position + Offset; } unsigned shiftedCodePosition(const Replacements &Replaces, unsigned Position) { return shiftedCodePositionInternal(Replaces, Position); d163 11 a173 1 return shiftedCodePositionInternal(Replaces, Position); d260 1 a260 3 IntrusiveRefCntPtr InMemoryFileSystem( new vfs::InMemoryFileSystem); FileManager Files(FileSystemOptions(), InMemoryFileSystem); d266 7 a272 4 InMemoryFileSystem->addFile( "", 0, llvm::MemoryBuffer::getMemBuffer(Code, "")); FileID ID = SourceMgr.createFileID(Files.getFile(""), SourceLocation(), clang::SrcMgr::C_User); a286 133 namespace { // Represents a merged replacement, i.e. a replacement consisting of multiple // overlapping replacements from 'First' and 'Second' in mergeReplacements. // // Position projection: // Offsets and lengths of the replacements can generally refer to two different // coordinate spaces. Replacements from 'First' refer to the original text // whereas replacements from 'Second' refer to the text after applying 'First'. // // MergedReplacement always operates in the coordinate space of the original // text, i.e. transforms elements from 'Second' to take into account what was // changed based on the elements from 'First'. // // We can correctly calculate this projection as we look at the replacements in // order of strictly increasing offsets. // // Invariants: // * We always merge elements from 'First' into elements from 'Second' and vice // versa. Within each set, the replacements are non-overlapping. // * We only extend to the right, i.e. merge elements with strictly increasing // offsets. class MergedReplacement { public: MergedReplacement(const Replacement &R, bool MergeSecond, int D) : MergeSecond(MergeSecond), Delta(D), FilePath(R.getFilePath()), Offset(R.getOffset() + (MergeSecond ? 0 : Delta)), Length(R.getLength()), Text(R.getReplacementText()) { Delta += MergeSecond ? 0 : Text.size() - Length; DeltaFirst = MergeSecond ? Text.size() - Length : 0; } // Merges the next element 'R' into this merged element. As we always merge // from 'First' into 'Second' or vice versa, the MergedReplacement knows what // set the next element is coming from. void merge(const Replacement &R) { if (MergeSecond) { unsigned REnd = R.getOffset() + Delta + R.getLength(); unsigned End = Offset + Text.size(); if (REnd > End) { Length += REnd - End; MergeSecond = false; } StringRef TextRef = Text; StringRef Head = TextRef.substr(0, R.getOffset() + Delta - Offset); StringRef Tail = TextRef.substr(REnd - Offset); Text = (Head + R.getReplacementText() + Tail).str(); Delta += R.getReplacementText().size() - R.getLength(); } else { unsigned End = Offset + Length; StringRef RText = R.getReplacementText(); StringRef Tail = RText.substr(End - R.getOffset()); Text = (Text + Tail).str(); if (R.getOffset() + RText.size() > End) { Length = R.getOffset() + R.getLength() - Offset; MergeSecond = true; } else { Length += R.getLength() - RText.size(); } DeltaFirst += RText.size() - R.getLength(); } } // Returns 'true' if 'R' starts strictly after the MergedReplacement and thus // doesn't need to be merged. bool endsBefore(const Replacement &R) const { if (MergeSecond) return Offset + Text.size() < R.getOffset() + Delta; return Offset + Length < R.getOffset(); } // Returns 'true' if an element from the second set should be merged next. bool mergeSecond() const { return MergeSecond; } int deltaFirst() const { return DeltaFirst; } Replacement asReplacement() const { return {FilePath, Offset, Length, Text}; } private: bool MergeSecond; // Amount of characters that elements from 'Second' need to be shifted by in // order to refer to the original text. int Delta; // Sum of all deltas (text-length - length) of elements from 'First' merged // into this element. This is used to update 'Delta' once the // MergedReplacement is completed. int DeltaFirst; // Data of the actually merged replacement. FilePath and Offset aren't changed // as the element is only extended to the right. const StringRef FilePath; const unsigned Offset; unsigned Length; std::string Text; }; } // namespace Replacements mergeReplacements(const Replacements &First, const Replacements &Second) { if (First.empty() || Second.empty()) return First.empty() ? Second : First; // Delta is the amount of characters that replacements from 'Second' need to // be shifted so that their offsets refer to the original text. int Delta = 0; Replacements Result; // Iterate over both sets and always add the next element (smallest total // Offset) from either 'First' or 'Second'. Merge that element with // subsequent replacements as long as they overlap. See more details in the // comment on MergedReplacement. for (auto FirstI = First.begin(), SecondI = Second.begin(); FirstI != First.end() || SecondI != Second.end();) { bool NextIsFirst = SecondI == Second.end() || (FirstI != First.end() && FirstI->getOffset() < SecondI->getOffset() + Delta); MergedReplacement Merged(NextIsFirst ? *FirstI : *SecondI, NextIsFirst, Delta); ++(NextIsFirst ? FirstI : SecondI); while ((Merged.mergeSecond() && SecondI != Second.end()) || (!Merged.mergeSecond() && FirstI != First.end())) { auto &I = Merged.mergeSecond() ? SecondI : FirstI; if (Merged.endsBefore(*I)) break; Merged.merge(*I); ++I; } Delta -= Merged.deltaFirst(); Result.insert(Merged.asReplacement()); } return Result; } @ 1.1.1.2.2.1 log @Sync with HEAD @ text @a13 2 #include "clang/Tooling/Core/Replacement.h" d21 1 a21 1 #include "llvm/ADT/SmallPtrSet.h" d31 2 a32 1 Replacement::Replacement() : FilePath(InvalidLocation) {} d60 8 a67 2 FileID ID = SM.getOrCreateFileID(Entry, SrcMgr::C_User); d92 3 d96 1 a96 1 return LHS.getLength() < RHS.getLength(); d146 13 a158 20 Replacement Replacements::getReplacementInChangedCode(const Replacement &R) const { unsigned NewStart = getShiftedCodePosition(R.getOffset()); unsigned NewEnd = getShiftedCodePosition(R.getOffset() + R.getLength()); return Replacement(R.getFilePath(), NewStart, NewEnd - NewStart, R.getReplacementText()); } static std::string getReplacementErrString(replacement_error Err) { switch (Err) { case replacement_error::fail_to_apply: return "Failed to apply a replacement."; case replacement_error::wrong_file_path: return "The new replacement's file path is different from the file path of " "existing replacements"; case replacement_error::overlap_conflict: return "The new replacement overlaps with an existing replacement."; case replacement_error::insert_conflict: return "The new insertion has the same insert location as an existing " "replacement."; d160 5 a164 1 llvm_unreachable("A value of replacement_error has no message."); d167 46 a212 23 std::string ReplacementError::message() const { std::string Message = getReplacementErrString(Err); if (NewReplacement.hasValue()) Message += "\nNew replacement: " + NewReplacement->toString(); if (ExistingReplacement.hasValue()) Message += "\nExisting replacement: " + ExistingReplacement->toString(); return Message; } char ReplacementError::ID = 0; Replacements Replacements::getCanonicalReplacements() const { std::vector NewReplaces; // Merge adjacent replacements. for (const auto &R : Replaces) { if (NewReplaces.empty()) { NewReplaces.push_back(R); continue; } auto &Prev = NewReplaces.back(); unsigned PrevEnd = Prev.getOffset() + Prev.getLength(); if (PrevEnd < R.getOffset()) { NewReplaces.push_back(R); d214 5 a218 6 assert(PrevEnd == R.getOffset() && "Existing replacements must not overlap."); Replacement NewR( R.getFilePath(), Prev.getOffset(), Prev.getLength() + R.getLength(), (Prev.getReplacementText() + R.getReplacementText()).str()); Prev = NewR; d221 3 a223 2 ReplacementsImpl NewReplacesImpl(NewReplaces.begin(), NewReplaces.end()); return Replacements(NewReplacesImpl.begin(), NewReplacesImpl.end()); d226 10 a235 39 // `R` and `Replaces` are order-independent if applying them in either order // has the same effect, so we need to compare replacements associated to // applying them in either order. llvm::Expected Replacements::mergeIfOrderIndependent(const Replacement &R) const { Replacements Rs(R); // A Replacements set containg a single replacement that is `R` referring to // the code after the existing replacements `Replaces` are applied. Replacements RsShiftedByReplaces(getReplacementInChangedCode(R)); // A Replacements set that is `Replaces` referring to the code after `R` is // applied. Replacements ReplacesShiftedByRs; for (const auto &Replace : Replaces) ReplacesShiftedByRs.Replaces.insert( Rs.getReplacementInChangedCode(Replace)); // This is equivalent to applying `Replaces` first and then `R`. auto MergeShiftedRs = merge(RsShiftedByReplaces); // This is equivalent to applying `R` first and then `Replaces`. auto MergeShiftedReplaces = Rs.merge(ReplacesShiftedByRs); // Since empty or segmented replacements around existing replacements might be // produced above, we need to compare replacements in canonical forms. if (MergeShiftedRs.getCanonicalReplacements() == MergeShiftedReplaces.getCanonicalReplacements()) return MergeShiftedRs; return llvm::make_error(replacement_error::overlap_conflict, R, *Replaces.begin()); } llvm::Error Replacements::add(const Replacement &R) { // Check the file path. if (!Replaces.empty() && R.getFilePath() != Replaces.begin()->getFilePath()) return llvm::make_error( replacement_error::wrong_file_path, R, *Replaces.begin()); // Special-case header insertions. if (R.getOffset() == UINT_MAX) { Replaces.insert(R); return llvm::Error::success(); d237 2 d240 12 a251 29 // This replacement cannot conflict with replacements that end before // this replacement starts or start after this replacement ends. // We also know that there currently are no overlapping replacements. // Thus, we know that all replacements that start after the end of the current // replacement cannot overlap. Replacement AtEnd(R.getFilePath(), R.getOffset() + R.getLength(), 0, ""); // Find the first entry that starts after or at the end of R. Note that // entries that start at the end can still be conflicting if R is an // insertion. auto I = Replaces.lower_bound(AtEnd); // If `I` starts at the same offset as `R`, `R` must be an insertion. if (I != Replaces.end() && R.getOffset() == I->getOffset()) { assert(R.getLength() == 0); // `I` is also an insertion, `R` and `I` conflict. if (I->getLength() == 0) { // Check if two insertions are order-indepedent: if inserting them in // either order produces the same text, they are order-independent. if ((R.getReplacementText() + I->getReplacementText()).str() != (I->getReplacementText() + R.getReplacementText()).str()) return llvm::make_error( replacement_error::insert_conflict, R, *I); // If insertions are order-independent, we can merge them. Replacement NewR( R.getFilePath(), R.getOffset(), 0, (R.getReplacementText() + I->getReplacementText()).str()); Replaces.erase(I); Replaces.insert(std::move(NewR)); return llvm::Error::success(); a252 9 // Insertion `R` is adjacent to a non-insertion replacement `I`, so they // are order-independent. It is safe to assume that `R` will not conflict // with any replacement before `I` since all replacements before `I` must // either end before `R` or end at `R` but has length > 0 (if the // replacement before `I` is an insertion at `R`, it would have been `I` // since it is a lower bound of `AtEnd` and ordered before the current `I` // in the set). Replaces.insert(R); return llvm::Error::success(); d254 2 d257 19 a275 5 // `I` is the smallest iterator (after `R`) whose entry cannot overlap. // If that is begin(), there are no overlaps. if (I == Replaces.begin()) { Replaces.insert(R); return llvm::Error::success(); d277 5 a281 38 --I; auto Overlap = [](const Replacement &R1, const Replacement &R2) -> bool { return Range(R1.getOffset(), R1.getLength()) .overlapsWith(Range(R2.getOffset(), R2.getLength())); }; // If the previous entry does not overlap, we know that entries before it // can also not overlap. if (!Overlap(R, *I)) { // If `R` and `I` do not have the same offset, it is safe to add `R` since // it must come after `I`. Otherwise: // - If `R` is an insertion, `I` must not be an insertion since it would // have come after `AtEnd`. // - If `R` is not an insertion, `I` must be an insertion; otherwise, `R` // and `I` would have overlapped. // In either case, we can safely insert `R`. Replaces.insert(R); } else { // `I` overlaps with `R`. We need to check `R` against all overlapping // replacements to see if they are order-indepedent. If they are, merge `R` // with them and replace them with the merged replacements. auto MergeBegin = I; auto MergeEnd = std::next(I); while (I != Replaces.begin()) { --I; // If `I` doesn't overlap with `R`, don't merge it. if (!Overlap(R, *I)) break; MergeBegin = I; } Replacements OverlapReplaces(MergeBegin, MergeEnd); llvm::Expected Merged = OverlapReplaces.mergeIfOrderIndependent(R); if (!Merged) return Merged.takeError(); Replaces.erase(MergeBegin, MergeEnd); Replaces.insert(Merged->begin(), Merged->end()); } return llvm::Error::success(); a284 1 d317 1 a317 1 // set the next element is coming from. a377 1 d380 4 a383 3 Replacements Replacements::merge(const Replacements &ReplacesToMerge) const { if (empty() || ReplacesToMerge.empty()) return empty() ? ReplacesToMerge : *this; a384 2 auto &First = Replaces; auto &Second = ReplacesToMerge.Replaces; d388 1 a388 1 ReplacementsImpl Result; a413 137 return Replacements(Result.begin(), Result.end()); } // Combines overlapping ranges in \p Ranges and sorts the combined ranges. // Returns a set of non-overlapping and sorted ranges that is equivalent to // \p Ranges. static std::vector combineAndSortRanges(std::vector Ranges) { std::sort(Ranges.begin(), Ranges.end(), [](const Range &LHS, const Range &RHS) { if (LHS.getOffset() != RHS.getOffset()) return LHS.getOffset() < RHS.getOffset(); return LHS.getLength() < RHS.getLength(); }); std::vector Result; for (const auto &R : Ranges) { if (Result.empty() || Result.back().getOffset() + Result.back().getLength() < R.getOffset()) { Result.push_back(R); } else { unsigned NewEnd = std::max(Result.back().getOffset() + Result.back().getLength(), R.getOffset() + R.getLength()); Result[Result.size() - 1] = Range(Result.back().getOffset(), NewEnd - Result.back().getOffset()); } } return Result; } std::vector calculateRangesAfterReplacements(const Replacements &Replaces, const std::vector &Ranges) { // To calculate the new ranges, // - Turn \p Ranges into Replacements at (offset, length) with an empty // (unimportant) replacement text of length "length". // - Merge with \p Replaces. // - The new ranges will be the affected ranges of the merged replacements. auto MergedRanges = combineAndSortRanges(Ranges); if (Replaces.empty()) return MergedRanges; tooling::Replacements FakeReplaces; for (const auto &R : MergedRanges) { auto Err = FakeReplaces.add(Replacement(Replaces.begin()->getFilePath(), R.getOffset(), R.getLength(), std::string(R.getLength(), ' '))); assert(!Err && "Replacements must not conflict since ranges have been merged."); (void)Err; } return FakeReplaces.merge(Replaces).getAffectedRanges(); } std::vector Replacements::getAffectedRanges() const { std::vector ChangedRanges; int Shift = 0; for (const Replacement &R : Replaces) { unsigned Offset = R.getOffset() + Shift; unsigned Length = R.getReplacementText().size(); Shift += Length - R.getLength(); ChangedRanges.push_back(Range(Offset, Length)); } return combineAndSortRanges(ChangedRanges); } unsigned Replacements::getShiftedCodePosition(unsigned Position) const { unsigned Offset = 0; for (const auto& R : Replaces) { if (R.getOffset() + R.getLength() <= Position) { Offset += R.getReplacementText().size() - R.getLength(); continue; } if (R.getOffset() < Position && R.getOffset() + R.getReplacementText().size() <= Position) { Position = R.getOffset() + R.getReplacementText().size(); if (R.getReplacementText().size() > 0) Position--; } break; } return Position + Offset; } bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite) { bool Result = true; for (auto I = Replaces.rbegin(), E = Replaces.rend(); I != E; ++I) { if (I->isApplicable()) { Result = I->apply(Rewrite) && Result; } else { Result = false; } } return Result; } llvm::Expected applyAllReplacements(StringRef Code, const Replacements &Replaces) { if (Replaces.empty()) return Code.str(); IntrusiveRefCntPtr InMemoryFileSystem( new vfs::InMemoryFileSystem); FileManager Files(FileSystemOptions(), InMemoryFileSystem); DiagnosticsEngine Diagnostics( IntrusiveRefCntPtr(new DiagnosticIDs), new DiagnosticOptions); SourceManager SourceMgr(Diagnostics, Files); Rewriter Rewrite(SourceMgr, LangOptions()); InMemoryFileSystem->addFile( "", 0, llvm::MemoryBuffer::getMemBuffer(Code, "")); FileID ID = SourceMgr.createFileID(Files.getFile(""), SourceLocation(), clang::SrcMgr::C_User); for (auto I = Replaces.rbegin(), E = Replaces.rend(); I != E; ++I) { Replacement Replace("", I->getOffset(), I->getLength(), I->getReplacementText()); if (!Replace.apply(Rewrite)) return llvm::make_error( replacement_error::fail_to_apply, Replace); } std::string Result; llvm::raw_string_ostream OS(Result); Rewrite.getEditBuffer(ID).write(OS); OS.flush(); return Result; } std::map groupReplacementsByFile( FileManager &FileMgr, const std::map &FileToReplaces) { std::map Result; llvm::SmallPtrSet ProcessedFileEntries; for (const auto &Entry : FileToReplaces) { const FileEntry *FE = FileMgr.getFile(Entry.first); if (!FE) llvm::errs() << "File path " << Entry.first << " is invalid.\n"; else if (ProcessedFileEntries.insert(FE).second) Result[Entry.first] = std::move(Entry.second); } d419 1 @ 1.1.1.3 log @Import Clang pre-4.0.0 r291444. @ text @a13 2 #include "clang/Tooling/Core/Replacement.h" d21 1 a21 1 #include "llvm/ADT/SmallPtrSet.h" d31 2 a32 1 Replacement::Replacement() : FilePath(InvalidLocation) {} d60 8 a67 2 FileID ID = SM.getOrCreateFileID(Entry, SrcMgr::C_User); d92 3 d96 1 a96 1 return LHS.getLength() < RHS.getLength(); d146 13 a158 20 Replacement Replacements::getReplacementInChangedCode(const Replacement &R) const { unsigned NewStart = getShiftedCodePosition(R.getOffset()); unsigned NewEnd = getShiftedCodePosition(R.getOffset() + R.getLength()); return Replacement(R.getFilePath(), NewStart, NewEnd - NewStart, R.getReplacementText()); } static std::string getReplacementErrString(replacement_error Err) { switch (Err) { case replacement_error::fail_to_apply: return "Failed to apply a replacement."; case replacement_error::wrong_file_path: return "The new replacement's file path is different from the file path of " "existing replacements"; case replacement_error::overlap_conflict: return "The new replacement overlaps with an existing replacement."; case replacement_error::insert_conflict: return "The new insertion has the same insert location as an existing " "replacement."; d160 5 a164 1 llvm_unreachable("A value of replacement_error has no message."); d167 46 a212 23 std::string ReplacementError::message() const { std::string Message = getReplacementErrString(Err); if (NewReplacement.hasValue()) Message += "\nNew replacement: " + NewReplacement->toString(); if (ExistingReplacement.hasValue()) Message += "\nExisting replacement: " + ExistingReplacement->toString(); return Message; } char ReplacementError::ID = 0; Replacements Replacements::getCanonicalReplacements() const { std::vector NewReplaces; // Merge adjacent replacements. for (const auto &R : Replaces) { if (NewReplaces.empty()) { NewReplaces.push_back(R); continue; } auto &Prev = NewReplaces.back(); unsigned PrevEnd = Prev.getOffset() + Prev.getLength(); if (PrevEnd < R.getOffset()) { NewReplaces.push_back(R); d214 5 a218 6 assert(PrevEnd == R.getOffset() && "Existing replacements must not overlap."); Replacement NewR( R.getFilePath(), Prev.getOffset(), Prev.getLength() + R.getLength(), (Prev.getReplacementText() + R.getReplacementText()).str()); Prev = NewR; d221 3 a223 2 ReplacementsImpl NewReplacesImpl(NewReplaces.begin(), NewReplaces.end()); return Replacements(NewReplacesImpl.begin(), NewReplacesImpl.end()); d226 10 a235 39 // `R` and `Replaces` are order-independent if applying them in either order // has the same effect, so we need to compare replacements associated to // applying them in either order. llvm::Expected Replacements::mergeIfOrderIndependent(const Replacement &R) const { Replacements Rs(R); // A Replacements set containg a single replacement that is `R` referring to // the code after the existing replacements `Replaces` are applied. Replacements RsShiftedByReplaces(getReplacementInChangedCode(R)); // A Replacements set that is `Replaces` referring to the code after `R` is // applied. Replacements ReplacesShiftedByRs; for (const auto &Replace : Replaces) ReplacesShiftedByRs.Replaces.insert( Rs.getReplacementInChangedCode(Replace)); // This is equivalent to applying `Replaces` first and then `R`. auto MergeShiftedRs = merge(RsShiftedByReplaces); // This is equivalent to applying `R` first and then `Replaces`. auto MergeShiftedReplaces = Rs.merge(ReplacesShiftedByRs); // Since empty or segmented replacements around existing replacements might be // produced above, we need to compare replacements in canonical forms. if (MergeShiftedRs.getCanonicalReplacements() == MergeShiftedReplaces.getCanonicalReplacements()) return MergeShiftedRs; return llvm::make_error(replacement_error::overlap_conflict, R, *Replaces.begin()); } llvm::Error Replacements::add(const Replacement &R) { // Check the file path. if (!Replaces.empty() && R.getFilePath() != Replaces.begin()->getFilePath()) return llvm::make_error( replacement_error::wrong_file_path, R, *Replaces.begin()); // Special-case header insertions. if (R.getOffset() == UINT_MAX) { Replaces.insert(R); return llvm::Error::success(); d237 2 d240 12 a251 29 // This replacement cannot conflict with replacements that end before // this replacement starts or start after this replacement ends. // We also know that there currently are no overlapping replacements. // Thus, we know that all replacements that start after the end of the current // replacement cannot overlap. Replacement AtEnd(R.getFilePath(), R.getOffset() + R.getLength(), 0, ""); // Find the first entry that starts after or at the end of R. Note that // entries that start at the end can still be conflicting if R is an // insertion. auto I = Replaces.lower_bound(AtEnd); // If `I` starts at the same offset as `R`, `R` must be an insertion. if (I != Replaces.end() && R.getOffset() == I->getOffset()) { assert(R.getLength() == 0); // `I` is also an insertion, `R` and `I` conflict. if (I->getLength() == 0) { // Check if two insertions are order-indepedent: if inserting them in // either order produces the same text, they are order-independent. if ((R.getReplacementText() + I->getReplacementText()).str() != (I->getReplacementText() + R.getReplacementText()).str()) return llvm::make_error( replacement_error::insert_conflict, R, *I); // If insertions are order-independent, we can merge them. Replacement NewR( R.getFilePath(), R.getOffset(), 0, (R.getReplacementText() + I->getReplacementText()).str()); Replaces.erase(I); Replaces.insert(std::move(NewR)); return llvm::Error::success(); a252 9 // Insertion `R` is adjacent to a non-insertion replacement `I`, so they // are order-independent. It is safe to assume that `R` will not conflict // with any replacement before `I` since all replacements before `I` must // either end before `R` or end at `R` but has length > 0 (if the // replacement before `I` is an insertion at `R`, it would have been `I` // since it is a lower bound of `AtEnd` and ordered before the current `I` // in the set). Replaces.insert(R); return llvm::Error::success(); d254 2 d257 19 a275 5 // `I` is the smallest iterator (after `R`) whose entry cannot overlap. // If that is begin(), there are no overlaps. if (I == Replaces.begin()) { Replaces.insert(R); return llvm::Error::success(); d277 5 a281 38 --I; auto Overlap = [](const Replacement &R1, const Replacement &R2) -> bool { return Range(R1.getOffset(), R1.getLength()) .overlapsWith(Range(R2.getOffset(), R2.getLength())); }; // If the previous entry does not overlap, we know that entries before it // can also not overlap. if (!Overlap(R, *I)) { // If `R` and `I` do not have the same offset, it is safe to add `R` since // it must come after `I`. Otherwise: // - If `R` is an insertion, `I` must not be an insertion since it would // have come after `AtEnd`. // - If `R` is not an insertion, `I` must be an insertion; otherwise, `R` // and `I` would have overlapped. // In either case, we can safely insert `R`. Replaces.insert(R); } else { // `I` overlaps with `R`. We need to check `R` against all overlapping // replacements to see if they are order-indepedent. If they are, merge `R` // with them and replace them with the merged replacements. auto MergeBegin = I; auto MergeEnd = std::next(I); while (I != Replaces.begin()) { --I; // If `I` doesn't overlap with `R`, don't merge it. if (!Overlap(R, *I)) break; MergeBegin = I; } Replacements OverlapReplaces(MergeBegin, MergeEnd); llvm::Expected Merged = OverlapReplaces.mergeIfOrderIndependent(R); if (!Merged) return Merged.takeError(); Replaces.erase(MergeBegin, MergeEnd); Replaces.insert(Merged->begin(), Merged->end()); } return llvm::Error::success(); a284 1 d317 1 a317 1 // set the next element is coming from. a377 1 d380 4 a383 3 Replacements Replacements::merge(const Replacements &ReplacesToMerge) const { if (empty() || ReplacesToMerge.empty()) return empty() ? ReplacesToMerge : *this; a384 2 auto &First = Replaces; auto &Second = ReplacesToMerge.Replaces; d388 1 a388 1 ReplacementsImpl Result; a413 137 return Replacements(Result.begin(), Result.end()); } // Combines overlapping ranges in \p Ranges and sorts the combined ranges. // Returns a set of non-overlapping and sorted ranges that is equivalent to // \p Ranges. static std::vector combineAndSortRanges(std::vector Ranges) { std::sort(Ranges.begin(), Ranges.end(), [](const Range &LHS, const Range &RHS) { if (LHS.getOffset() != RHS.getOffset()) return LHS.getOffset() < RHS.getOffset(); return LHS.getLength() < RHS.getLength(); }); std::vector Result; for (const auto &R : Ranges) { if (Result.empty() || Result.back().getOffset() + Result.back().getLength() < R.getOffset()) { Result.push_back(R); } else { unsigned NewEnd = std::max(Result.back().getOffset() + Result.back().getLength(), R.getOffset() + R.getLength()); Result[Result.size() - 1] = Range(Result.back().getOffset(), NewEnd - Result.back().getOffset()); } } return Result; } std::vector calculateRangesAfterReplacements(const Replacements &Replaces, const std::vector &Ranges) { // To calculate the new ranges, // - Turn \p Ranges into Replacements at (offset, length) with an empty // (unimportant) replacement text of length "length". // - Merge with \p Replaces. // - The new ranges will be the affected ranges of the merged replacements. auto MergedRanges = combineAndSortRanges(Ranges); if (Replaces.empty()) return MergedRanges; tooling::Replacements FakeReplaces; for (const auto &R : MergedRanges) { auto Err = FakeReplaces.add(Replacement(Replaces.begin()->getFilePath(), R.getOffset(), R.getLength(), std::string(R.getLength(), ' '))); assert(!Err && "Replacements must not conflict since ranges have been merged."); (void)Err; } return FakeReplaces.merge(Replaces).getAffectedRanges(); } std::vector Replacements::getAffectedRanges() const { std::vector ChangedRanges; int Shift = 0; for (const Replacement &R : Replaces) { unsigned Offset = R.getOffset() + Shift; unsigned Length = R.getReplacementText().size(); Shift += Length - R.getLength(); ChangedRanges.push_back(Range(Offset, Length)); } return combineAndSortRanges(ChangedRanges); } unsigned Replacements::getShiftedCodePosition(unsigned Position) const { unsigned Offset = 0; for (const auto& R : Replaces) { if (R.getOffset() + R.getLength() <= Position) { Offset += R.getReplacementText().size() - R.getLength(); continue; } if (R.getOffset() < Position && R.getOffset() + R.getReplacementText().size() <= Position) { Position = R.getOffset() + R.getReplacementText().size(); if (R.getReplacementText().size() > 0) Position--; } break; } return Position + Offset; } bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite) { bool Result = true; for (auto I = Replaces.rbegin(), E = Replaces.rend(); I != E; ++I) { if (I->isApplicable()) { Result = I->apply(Rewrite) && Result; } else { Result = false; } } return Result; } llvm::Expected applyAllReplacements(StringRef Code, const Replacements &Replaces) { if (Replaces.empty()) return Code.str(); IntrusiveRefCntPtr InMemoryFileSystem( new vfs::InMemoryFileSystem); FileManager Files(FileSystemOptions(), InMemoryFileSystem); DiagnosticsEngine Diagnostics( IntrusiveRefCntPtr(new DiagnosticIDs), new DiagnosticOptions); SourceManager SourceMgr(Diagnostics, Files); Rewriter Rewrite(SourceMgr, LangOptions()); InMemoryFileSystem->addFile( "", 0, llvm::MemoryBuffer::getMemBuffer(Code, "")); FileID ID = SourceMgr.createFileID(Files.getFile(""), SourceLocation(), clang::SrcMgr::C_User); for (auto I = Replaces.rbegin(), E = Replaces.rend(); I != E; ++I) { Replacement Replace("", I->getOffset(), I->getLength(), I->getReplacementText()); if (!Replace.apply(Rewrite)) return llvm::make_error( replacement_error::fail_to_apply, Replace); } std::string Result; llvm::raw_string_ostream OS(Result); Rewrite.getEditBuffer(ID).write(OS); OS.flush(); return Result; } std::map groupReplacementsByFile( FileManager &FileMgr, const std::map &FileToReplaces) { std::map Result; llvm::SmallPtrSet ProcessedFileEntries; for (const auto &Entry : FileToReplaces) { const FileEntry *FE = FileMgr.getFile(Entry.first); if (!FE) llvm::errs() << "File path " << Entry.first << " is invalid.\n"; else if (ProcessedFileEntries.insert(FE).second) Result[Entry.first] = std::move(Entry.second); } d419 1 @ 1.1.1.3.14.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- Replacement.cpp - Framework for clang refactoring tools ------------===// d15 1 a19 2 #include "clang/Basic/FileSystemOptions.h" #include "clang/Basic/SourceLocation.h" a20 1 #include "clang/Basic/VirtualFileSystem.h" a21 1 #include "clang/Rewrite/Core/RewriteBuffer.h" a22 1 #include "llvm/ADT/IntrusiveRefCntPtr.h" d24 3 a26 12 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Error.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/raw_ostream.h" #include #include #include #include #include #include #include d28 2 a29 2 using namespace clang; using namespace tooling; a82 3 namespace clang { namespace tooling { a101 3 } // namespace tooling } // namespace clang d204 1 a204 1 // A Replacements set containing a single replacement that is `R` referring to d234 1 a234 1 if (R.getOffset() == std::numeric_limits::max()) { a398 1 d466 5 a470 5 llvm::sort(Ranges.begin(), Ranges.end(), [](const Range &LHS, const Range &RHS) { if (LHS.getOffset() != RHS.getOffset()) return LHS.getOffset() < RHS.getOffset(); return LHS.getLength() < RHS.getLength(); a487 3 namespace clang { namespace tooling { d506 1 a506 1 llvm::consumeError(std::move(Err)); a510 3 } // namespace tooling } // namespace clang d514 1 a514 1 for (const auto &R : Replaces) { d525 1 a525 1 for (const auto &R : Replaces) { d533 1 a533 1 if (!R.getReplacementText().empty()) a540 3 namespace clang { namespace tooling { d599 2 a600 2 } // namespace tooling } // namespace clang @ 1.1.1.3.14.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.3.12.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- Replacement.cpp - Framework for clang refactoring tools ------------===// d15 1 a19 2 #include "clang/Basic/FileSystemOptions.h" #include "clang/Basic/SourceLocation.h" a20 1 #include "clang/Basic/VirtualFileSystem.h" a21 1 #include "clang/Rewrite/Core/RewriteBuffer.h" a22 1 #include "llvm/ADT/IntrusiveRefCntPtr.h" d24 3 a26 12 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Error.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/raw_ostream.h" #include #include #include #include #include #include #include d28 2 a29 2 using namespace clang; using namespace tooling; a82 3 namespace clang { namespace tooling { a101 3 } // namespace tooling } // namespace clang d204 1 a204 1 // A Replacements set containing a single replacement that is `R` referring to d234 1 a234 1 if (R.getOffset() == std::numeric_limits::max()) { a398 1 d466 5 a470 5 llvm::sort(Ranges.begin(), Ranges.end(), [](const Range &LHS, const Range &RHS) { if (LHS.getOffset() != RHS.getOffset()) return LHS.getOffset() < RHS.getOffset(); return LHS.getLength() < RHS.getLength(); a487 3 namespace clang { namespace tooling { d506 1 a506 1 llvm::consumeError(std::move(Err)); a510 3 } // namespace tooling } // namespace clang d514 1 a514 1 for (const auto &R : Replaces) { d525 1 a525 1 for (const auto &R : Replaces) { d533 1 a533 1 if (!R.getReplacementText().empty()) a540 3 namespace clang { namespace tooling { d599 2 a600 2 } // namespace tooling } // namespace clang @ 1.1.1.4 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- Replacement.cpp - Framework for clang refactoring tools ------------===// d15 1 a19 2 #include "clang/Basic/FileSystemOptions.h" #include "clang/Basic/SourceLocation.h" a20 1 #include "clang/Basic/VirtualFileSystem.h" a21 1 #include "clang/Rewrite/Core/RewriteBuffer.h" a22 1 #include "llvm/ADT/IntrusiveRefCntPtr.h" d24 3 a26 12 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Error.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/raw_ostream.h" #include #include #include #include #include #include #include d28 2 a29 2 using namespace clang; using namespace tooling; a82 3 namespace clang { namespace tooling { a101 3 } // namespace tooling } // namespace clang d204 1 a204 1 // A Replacements set containing a single replacement that is `R` referring to d234 1 a234 1 if (R.getOffset() == std::numeric_limits::max()) { a398 1 d466 5 a470 5 llvm::sort(Ranges.begin(), Ranges.end(), [](const Range &LHS, const Range &RHS) { if (LHS.getOffset() != RHS.getOffset()) return LHS.getOffset() < RHS.getOffset(); return LHS.getLength() < RHS.getLength(); a487 3 namespace clang { namespace tooling { d506 1 a506 1 llvm::consumeError(std::move(Err)); a510 3 } // namespace tooling } // namespace clang d514 1 a514 1 for (const auto &R : Replaces) { d525 1 a525 1 for (const auto &R : Replaces) { d533 1 a533 1 if (!R.getReplacementText().empty()) a540 3 namespace clang { namespace tooling { d599 2 a600 2 } // namespace tooling } // namespace clang @ 1.1.1.5 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.1.2.1 log @file Replacement.cpp was added on branch netbsd-7 on 2015-06-04 20:04:31 +0000 @ text @d1 289 @ 1.1.1.1.2.2 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a0 289 //===--- Replacement.cpp - Framework for clang refactoring tools ----------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Implements classes to support/store refactorings. // //===----------------------------------------------------------------------===// #include "clang/Basic/Diagnostic.h" #include "clang/Basic/DiagnosticIDs.h" #include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/Lexer.h" #include "clang/Rewrite/Core/Rewriter.h" #include "clang/Tooling/Core/Replacement.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_os_ostream.h" namespace clang { namespace tooling { static const char * const InvalidLocation = ""; Replacement::Replacement() : FilePath(InvalidLocation) {} Replacement::Replacement(StringRef FilePath, unsigned Offset, unsigned Length, StringRef ReplacementText) : FilePath(FilePath), ReplacementRange(Offset, Length), ReplacementText(ReplacementText) {} Replacement::Replacement(const SourceManager &Sources, SourceLocation Start, unsigned Length, StringRef ReplacementText) { setFromSourceLocation(Sources, Start, Length, ReplacementText); } Replacement::Replacement(const SourceManager &Sources, const CharSourceRange &Range, StringRef ReplacementText) { setFromSourceRange(Sources, Range, ReplacementText); } bool Replacement::isApplicable() const { return FilePath != InvalidLocation; } bool Replacement::apply(Rewriter &Rewrite) const { SourceManager &SM = Rewrite.getSourceMgr(); const FileEntry *Entry = SM.getFileManager().getFile(FilePath); if (!Entry) return false; FileID ID; // FIXME: Use SM.translateFile directly. SourceLocation Location = SM.translateFileLineCol(Entry, 1, 1); ID = Location.isValid() ? SM.getFileID(Location) : SM.createFileID(Entry, SourceLocation(), SrcMgr::C_User); // FIXME: We cannot check whether Offset + Length is in the file, as // the remapping API is not public in the RewriteBuffer. const SourceLocation Start = SM.getLocForStartOfFile(ID). getLocWithOffset(ReplacementRange.getOffset()); // ReplaceText returns false on success. // ReplaceText only fails if the source location is not a file location, in // which case we already returned false earlier. bool RewriteSucceeded = !Rewrite.ReplaceText( Start, ReplacementRange.getLength(), ReplacementText); assert(RewriteSucceeded); return RewriteSucceeded; } std::string Replacement::toString() const { std::string result; llvm::raw_string_ostream stream(result); stream << FilePath << ": " << ReplacementRange.getOffset() << ":+" << ReplacementRange.getLength() << ":\"" << ReplacementText << "\""; return result; } bool operator<(const Replacement &LHS, const Replacement &RHS) { if (LHS.getOffset() != RHS.getOffset()) return LHS.getOffset() < RHS.getOffset(); if (LHS.getLength() != RHS.getLength()) return LHS.getLength() < RHS.getLength(); if (LHS.getFilePath() != RHS.getFilePath()) return LHS.getFilePath() < RHS.getFilePath(); return LHS.getReplacementText() < RHS.getReplacementText(); } bool operator==(const Replacement &LHS, const Replacement &RHS) { return LHS.getOffset() == RHS.getOffset() && LHS.getLength() == RHS.getLength() && LHS.getFilePath() == RHS.getFilePath() && LHS.getReplacementText() == RHS.getReplacementText(); } void Replacement::setFromSourceLocation(const SourceManager &Sources, SourceLocation Start, unsigned Length, StringRef ReplacementText) { const std::pair DecomposedLocation = Sources.getDecomposedLoc(Start); const FileEntry *Entry = Sources.getFileEntryForID(DecomposedLocation.first); if (Entry) { // Make FilePath absolute so replacements can be applied correctly when // relative paths for files are used. llvm::SmallString<256> FilePath(Entry->getName()); std::error_code EC = llvm::sys::fs::make_absolute(FilePath); this->FilePath = EC ? FilePath.c_str() : Entry->getName(); } else { this->FilePath = InvalidLocation; } this->ReplacementRange = Range(DecomposedLocation.second, Length); this->ReplacementText = ReplacementText; } // FIXME: This should go into the Lexer, but we need to figure out how // to handle ranges for refactoring in general first - there is no obvious // good way how to integrate this into the Lexer yet. static int getRangeSize(const SourceManager &Sources, const CharSourceRange &Range) { SourceLocation SpellingBegin = Sources.getSpellingLoc(Range.getBegin()); SourceLocation SpellingEnd = Sources.getSpellingLoc(Range.getEnd()); std::pair Start = Sources.getDecomposedLoc(SpellingBegin); std::pair End = Sources.getDecomposedLoc(SpellingEnd); if (Start.first != End.first) return -1; if (Range.isTokenRange()) End.second += Lexer::MeasureTokenLength(SpellingEnd, Sources, LangOptions()); return End.second - Start.second; } void Replacement::setFromSourceRange(const SourceManager &Sources, const CharSourceRange &Range, StringRef ReplacementText) { setFromSourceLocation(Sources, Sources.getSpellingLoc(Range.getBegin()), getRangeSize(Sources, Range), ReplacementText); } unsigned shiftedCodePosition(const Replacements &Replaces, unsigned Position) { unsigned NewPosition = Position; for (Replacements::iterator I = Replaces.begin(), E = Replaces.end(); I != E; ++I) { if (I->getOffset() >= Position) break; if (I->getOffset() + I->getLength() > Position) NewPosition += I->getOffset() + I->getLength() - Position; NewPosition += I->getReplacementText().size() - I->getLength(); } return NewPosition; } // FIXME: Remove this function when Replacements is implemented as std::vector // instead of std::set. unsigned shiftedCodePosition(const std::vector &Replaces, unsigned Position) { unsigned NewPosition = Position; for (std::vector::const_iterator I = Replaces.begin(), E = Replaces.end(); I != E; ++I) { if (I->getOffset() >= Position) break; if (I->getOffset() + I->getLength() > Position) NewPosition += I->getOffset() + I->getLength() - Position; NewPosition += I->getReplacementText().size() - I->getLength(); } return NewPosition; } void deduplicate(std::vector &Replaces, std::vector &Conflicts) { if (Replaces.empty()) return; auto LessNoPath = [](const Replacement &LHS, const Replacement &RHS) { if (LHS.getOffset() != RHS.getOffset()) return LHS.getOffset() < RHS.getOffset(); if (LHS.getLength() != RHS.getLength()) return LHS.getLength() < RHS.getLength(); return LHS.getReplacementText() < RHS.getReplacementText(); }; auto EqualNoPath = [](const Replacement &LHS, const Replacement &RHS) { return LHS.getOffset() == RHS.getOffset() && LHS.getLength() == RHS.getLength() && LHS.getReplacementText() == RHS.getReplacementText(); }; // Deduplicate. We don't want to deduplicate based on the path as we assume // that all replacements refer to the same file (or are symlinks). std::sort(Replaces.begin(), Replaces.end(), LessNoPath); Replaces.erase(std::unique(Replaces.begin(), Replaces.end(), EqualNoPath), Replaces.end()); // Detect conflicts Range ConflictRange(Replaces.front().getOffset(), Replaces.front().getLength()); unsigned ConflictStart = 0; unsigned ConflictLength = 1; for (unsigned i = 1; i < Replaces.size(); ++i) { Range Current(Replaces[i].getOffset(), Replaces[i].getLength()); if (ConflictRange.overlapsWith(Current)) { // Extend conflicted range ConflictRange = Range(ConflictRange.getOffset(), std::max(ConflictRange.getLength(), Current.getOffset() + Current.getLength() - ConflictRange.getOffset())); ++ConflictLength; } else { if (ConflictLength > 1) Conflicts.push_back(Range(ConflictStart, ConflictLength)); ConflictRange = Current; ConflictStart = i; ConflictLength = 1; } } if (ConflictLength > 1) Conflicts.push_back(Range(ConflictStart, ConflictLength)); } bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite) { bool Result = true; for (Replacements::const_iterator I = Replaces.begin(), E = Replaces.end(); I != E; ++I) { if (I->isApplicable()) { Result = I->apply(Rewrite) && Result; } else { Result = false; } } return Result; } // FIXME: Remove this function when Replacements is implemented as std::vector // instead of std::set. bool applyAllReplacements(const std::vector &Replaces, Rewriter &Rewrite) { bool Result = true; for (std::vector::const_iterator I = Replaces.begin(), E = Replaces.end(); I != E; ++I) { if (I->isApplicable()) { Result = I->apply(Rewrite) && Result; } else { Result = false; } } return Result; } std::string applyAllReplacements(StringRef Code, const Replacements &Replaces) { FileManager Files((FileSystemOptions())); DiagnosticsEngine Diagnostics( IntrusiveRefCntPtr(new DiagnosticIDs), new DiagnosticOptions); SourceManager SourceMgr(Diagnostics, Files); Rewriter Rewrite(SourceMgr, LangOptions()); std::unique_ptr Buf = llvm::MemoryBuffer::getMemBuffer(Code, ""); const clang::FileEntry *Entry = Files.getVirtualFile("", Buf->getBufferSize(), 0); SourceMgr.overrideFileContents(Entry, std::move(Buf)); FileID ID = SourceMgr.createFileID(Entry, SourceLocation(), clang::SrcMgr::C_User); for (Replacements::const_iterator I = Replaces.begin(), E = Replaces.end(); I != E; ++I) { Replacement Replace("", I->getOffset(), I->getLength(), I->getReplacementText()); if (!Replace.apply(Rewrite)) return ""; } std::string Result; llvm::raw_string_ostream OS(Result); Rewrite.getEditBuffer(ID).write(OS); OS.flush(); return Result; } } // end namespace tooling } // end namespace clang @