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 26 namespace clang { 27 namespace tooling { 28 29 static const char * const InvalidLocation = ""; 30 31 Replacement::Replacement() 32 : FilePath(InvalidLocation) {} 33 34 Replacement::Replacement(StringRef FilePath, unsigned Offset, unsigned Length, 35 StringRef ReplacementText) 36 : FilePath(FilePath), ReplacementRange(Offset, Length), 37 ReplacementText(ReplacementText) {} 38 39 Replacement::Replacement(const SourceManager &Sources, SourceLocation Start, 40 unsigned Length, StringRef ReplacementText) { 41 setFromSourceLocation(Sources, Start, Length, ReplacementText); 42 } 43 44 Replacement::Replacement(const SourceManager &Sources, 45 const CharSourceRange &Range, 46 StringRef ReplacementText) { 47 setFromSourceRange(Sources, Range, ReplacementText); 48 } 49 50 bool Replacement::isApplicable() const { 51 return FilePath != InvalidLocation; 52 } 53 54 bool 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 79 std::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 87 bool 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 97 bool 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 104 void 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. 126 static 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 139 void 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 146 unsigned 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. 161 unsigned 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 176 void 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 228 bool 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. 244 bool 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 259 std::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
