1//===--- Replacement.cpp - Framework for clang refactoring tools ----------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// Implements classes to support/store refactorings. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Basic/Diagnostic.h" 15#include "clang/Basic/DiagnosticIDs.h" 16#include "clang/Basic/DiagnosticOptions.h" 17#include "clang/Basic/FileManager.h" 18#include "clang/Basic/SourceManager.h" 19#include "clang/Lex/Lexer.h" 20#include "clang/Rewrite/Core/Rewriter.h" 21#include "clang/Tooling/Core/Replacement.h" 22#include "llvm/Support/FileSystem.h" 23#include "llvm/Support/Path.h" 24#include "llvm/Support/raw_os_ostream.h" 25 26namespace clang { 27namespace tooling { 28 29static const char * const InvalidLocation = ""; 30 31Replacement::Replacement() 32 : FilePath(InvalidLocation) {} 33 34Replacement::Replacement(StringRef FilePath, unsigned Offset, unsigned Length, 35 StringRef ReplacementText) 36 : FilePath(FilePath), ReplacementRange(Offset, Length), 37 ReplacementText(ReplacementText) {} 38 39Replacement::Replacement(const SourceManager &Sources, SourceLocation Start, 40 unsigned Length, StringRef ReplacementText) { 41 setFromSourceLocation(Sources, Start, Length, ReplacementText); 42} 43 44Replacement::Replacement(const SourceManager &Sources, 45 const CharSourceRange &Range, 46 StringRef ReplacementText) { 47 setFromSourceRange(Sources, Range, ReplacementText); 48} 49 50bool Replacement::isApplicable() const { 51 return FilePath != InvalidLocation; 52} 53 54bool Replacement::apply(Rewriter &Rewrite) const { 55 SourceManager &SM = Rewrite.getSourceMgr(); 56 const FileEntry *Entry = SM.getFileManager().getFile(FilePath); 57 if (!Entry) 58 return false; 59 FileID ID; 60 // FIXME: Use SM.translateFile directly. 61 SourceLocation Location = SM.translateFileLineCol(Entry, 1, 1); 62 ID = Location.isValid() ? 63 SM.getFileID(Location) : 64 SM.createFileID(Entry, SourceLocation(), SrcMgr::C_User); 65 // FIXME: We cannot check whether Offset + Length is in the file, as 66 // the remapping API is not public in the RewriteBuffer. 67 const SourceLocation Start = 68 SM.getLocForStartOfFile(ID). 69 getLocWithOffset(ReplacementRange.getOffset()); 70 // ReplaceText returns false on success. 71 // ReplaceText only fails if the source location is not a file location, in 72 // which case we already returned false earlier. 73 bool RewriteSucceeded = !Rewrite.ReplaceText( 74 Start, ReplacementRange.getLength(), ReplacementText); 75 assert(RewriteSucceeded); 76 return RewriteSucceeded; 77} 78 79std::string Replacement::toString() const { 80 std::string result; 81 llvm::raw_string_ostream stream(result); 82 stream << FilePath << ": " << ReplacementRange.getOffset() << ":+" 83 << ReplacementRange.getLength() << ":\"" << ReplacementText << "\""; 84 return result; 85} 86 87bool operator<(const Replacement &LHS, const Replacement &RHS) { 88 if (LHS.getOffset() != RHS.getOffset()) 89 return LHS.getOffset() < RHS.getOffset(); 90 if (LHS.getLength() != RHS.getLength()) 91 return LHS.getLength() < RHS.getLength(); 92 if (LHS.getFilePath() != RHS.getFilePath()) 93 return LHS.getFilePath() < RHS.getFilePath(); 94 return LHS.getReplacementText() < RHS.getReplacementText(); 95} 96 97bool operator==(const Replacement &LHS, const Replacement &RHS) { 98 return LHS.getOffset() == RHS.getOffset() && 99 LHS.getLength() == RHS.getLength() && 100 LHS.getFilePath() == RHS.getFilePath() && 101 LHS.getReplacementText() == RHS.getReplacementText(); 102} 103 104void Replacement::setFromSourceLocation(const SourceManager &Sources, 105 SourceLocation Start, unsigned Length, 106 StringRef ReplacementText) { 107 const std::pair<FileID, unsigned> DecomposedLocation = 108 Sources.getDecomposedLoc(Start); 109 const FileEntry *Entry = Sources.getFileEntryForID(DecomposedLocation.first); 110 if (Entry) { 111 // Make FilePath absolute so replacements can be applied correctly when 112 // relative paths for files are used. 113 llvm::SmallString<256> FilePath(Entry->getName()); 114 std::error_code EC = llvm::sys::fs::make_absolute(FilePath); 115 this->FilePath = EC ? FilePath.c_str() : Entry->getName(); 116 } else { 117 this->FilePath = InvalidLocation; 118 } 119 this->ReplacementRange = Range(DecomposedLocation.second, Length); 120 this->ReplacementText = ReplacementText; 121} 122 123// FIXME: This should go into the Lexer, but we need to figure out how 124// to handle ranges for refactoring in general first - there is no obvious 125// good way how to integrate this into the Lexer yet. 126static int getRangeSize(const SourceManager &Sources, 127 const CharSourceRange &Range) { 128 SourceLocation SpellingBegin = Sources.getSpellingLoc(Range.getBegin()); 129 SourceLocation SpellingEnd = Sources.getSpellingLoc(Range.getEnd()); 130 std::pair<FileID, unsigned> Start = Sources.getDecomposedLoc(SpellingBegin); 131 std::pair<FileID, unsigned> End = Sources.getDecomposedLoc(SpellingEnd); 132 if (Start.first != End.first) return -1; 133 if (Range.isTokenRange()) 134 End.second += Lexer::MeasureTokenLength(SpellingEnd, Sources, 135 LangOptions()); 136 return End.second - Start.second; 137} 138 139void Replacement::setFromSourceRange(const SourceManager &Sources, 140 const CharSourceRange &Range, 141 StringRef ReplacementText) { 142 setFromSourceLocation(Sources, Sources.getSpellingLoc(Range.getBegin()), 143 getRangeSize(Sources, Range), ReplacementText); 144} 145 146unsigned shiftedCodePosition(const Replacements &Replaces, unsigned Position) { 147 unsigned NewPosition = Position; 148 for (Replacements::iterator I = Replaces.begin(), E = Replaces.end(); I != E; 149 ++I) { 150 if (I->getOffset() >= Position) 151 break; 152 if (I->getOffset() + I->getLength() > Position) 153 NewPosition += I->getOffset() + I->getLength() - Position; 154 NewPosition += I->getReplacementText().size() - I->getLength(); 155 } 156 return NewPosition; 157} 158 159// FIXME: Remove this function when Replacements is implemented as std::vector 160// instead of std::set. 161unsigned shiftedCodePosition(const std::vector<Replacement> &Replaces, 162 unsigned Position) { 163 unsigned NewPosition = Position; 164 for (std::vector<Replacement>::const_iterator I = Replaces.begin(), 165 E = Replaces.end(); 166 I != E; ++I) { 167 if (I->getOffset() >= Position) 168 break; 169 if (I->getOffset() + I->getLength() > Position) 170 NewPosition += I->getOffset() + I->getLength() - Position; 171 NewPosition += I->getReplacementText().size() - I->getLength(); 172 } 173 return NewPosition; 174} 175 176void deduplicate(std::vector<Replacement> &Replaces, 177 std::vector<Range> &Conflicts) { 178 if (Replaces.empty()) 179 return; 180 181 auto LessNoPath = [](const Replacement &LHS, const Replacement &RHS) { 182 if (LHS.getOffset() != RHS.getOffset()) 183 return LHS.getOffset() < RHS.getOffset(); 184 if (LHS.getLength() != RHS.getLength()) 185 return LHS.getLength() < RHS.getLength(); 186 return LHS.getReplacementText() < RHS.getReplacementText(); 187 }; 188 189 auto EqualNoPath = [](const Replacement &LHS, const Replacement &RHS) { 190 return LHS.getOffset() == RHS.getOffset() && 191 LHS.getLength() == RHS.getLength() && 192 LHS.getReplacementText() == RHS.getReplacementText(); 193 }; 194 195 // Deduplicate. We don't want to deduplicate based on the path as we assume 196 // that all replacements refer to the same file (or are symlinks). 197 std::sort(Replaces.begin(), Replaces.end(), LessNoPath); 198 Replaces.erase(std::unique(Replaces.begin(), Replaces.end(), EqualNoPath), 199 Replaces.end()); 200 201 // Detect conflicts 202 Range ConflictRange(Replaces.front().getOffset(), 203 Replaces.front().getLength()); 204 unsigned ConflictStart = 0; 205 unsigned ConflictLength = 1; 206 for (unsigned i = 1; i < Replaces.size(); ++i) { 207 Range Current(Replaces[i].getOffset(), Replaces[i].getLength()); 208 if (ConflictRange.overlapsWith(Current)) { 209 // Extend conflicted range 210 ConflictRange = Range(ConflictRange.getOffset(), 211 std::max(ConflictRange.getLength(), 212 Current.getOffset() + Current.getLength() - 213 ConflictRange.getOffset())); 214 ++ConflictLength; 215 } else { 216 if (ConflictLength > 1) 217 Conflicts.push_back(Range(ConflictStart, ConflictLength)); 218 ConflictRange = Current; 219 ConflictStart = i; 220 ConflictLength = 1; 221 } 222 } 223 224 if (ConflictLength > 1) 225 Conflicts.push_back(Range(ConflictStart, ConflictLength)); 226} 227 228bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite) { 229 bool Result = true; 230 for (Replacements::const_iterator I = Replaces.begin(), 231 E = Replaces.end(); 232 I != E; ++I) { 233 if (I->isApplicable()) { 234 Result = I->apply(Rewrite) && Result; 235 } else { 236 Result = false; 237 } 238 } 239 return Result; 240} 241 242// FIXME: Remove this function when Replacements is implemented as std::vector 243// instead of std::set. 244bool applyAllReplacements(const std::vector<Replacement> &Replaces, 245 Rewriter &Rewrite) { 246 bool Result = true; 247 for (std::vector<Replacement>::const_iterator I = Replaces.begin(), 248 E = Replaces.end(); 249 I != E; ++I) { 250 if (I->isApplicable()) { 251 Result = I->apply(Rewrite) && Result; 252 } else { 253 Result = false; 254 } 255 } 256 return Result; 257} 258 259std::string applyAllReplacements(StringRef Code, const Replacements &Replaces) { 260 FileManager Files((FileSystemOptions())); 261 DiagnosticsEngine Diagnostics( 262 IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), 263 new DiagnosticOptions); 264 SourceManager SourceMgr(Diagnostics, Files); 265 Rewriter Rewrite(SourceMgr, LangOptions()); 266 std::unique_ptr<llvm::MemoryBuffer> Buf = 267 llvm::MemoryBuffer::getMemBuffer(Code, "<stdin>"); 268 const clang::FileEntry *Entry = 269 Files.getVirtualFile("<stdin>", Buf->getBufferSize(), 0); 270 SourceMgr.overrideFileContents(Entry, std::move(Buf)); 271 FileID ID = 272 SourceMgr.createFileID(Entry, SourceLocation(), clang::SrcMgr::C_User); 273 for (Replacements::const_iterator I = Replaces.begin(), E = Replaces.end(); 274 I != E; ++I) { 275 Replacement Replace("<stdin>", I->getOffset(), I->getLength(), 276 I->getReplacementText()); 277 if (!Replace.apply(Rewrite)) 278 return ""; 279 } 280 std::string Result; 281 llvm::raw_string_ostream OS(Result); 282 Rewrite.getEditBuffer(ID).write(OS); 283 OS.flush(); 284 return Result; 285} 286 287} // end namespace tooling 288} // end namespace clang 289 290