| 1 |
//===-- TransformActions.cpp - Migration to ARC mode ----------------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
|
| 9 |
#include "Internals.h" |
| 10 |
#include "clang/AST/ASTContext.h" |
| 11 |
#include "clang/AST/Expr.h" |
| 12 |
#include "clang/Basic/SourceManager.h" |
| 13 |
#include "clang/Lex/Preprocessor.h" |
| 14 |
#include "llvm/ADT/DenseSet.h" |
| 15 |
#include <map> |
| 16 |
using namespace clang; |
| 17 |
using namespace arcmt; |
| 18 |
|
| 19 |
namespace { |
| 20 |
|
| 21 |
/// Collects transformations and merges them before applying them with |
| 22 |
/// with applyRewrites(). E.g. if the same source range |
| 23 |
/// is requested to be removed twice, only one rewriter remove will be invoked. |
| 24 |
/// Rewrites happen in "transactions"; if one rewrite in the transaction cannot |
| 25 |
/// be done (e.g. it resides in a macro) all rewrites in the transaction are |
| 26 |
/// aborted. |
| 27 |
/// FIXME: "Transactional" rewrites support should be baked in the Rewriter. |
| 28 |
class TransformActionsImpl { |
| 29 |
CapturedDiagList &CapturedDiags; |
| 30 |
ASTContext &Ctx; |
| 31 |
Preprocessor &PP; |
| 32 |
|
| 33 |
bool IsInTransaction; |
| 34 |
|
| 35 |
enum ActionKind { |
| 36 |
Act_Insert, Act_InsertAfterToken, |
| 37 |
Act_Remove, Act_RemoveStmt, |
| 38 |
Act_Replace, Act_ReplaceText, |
| 39 |
Act_IncreaseIndentation, |
| 40 |
Act_ClearDiagnostic |
| 41 |
}; |
| 42 |
|
| 43 |
struct ActionData { |
| 44 |
ActionKind Kind; |
| 45 |
SourceLocation Loc; |
| 46 |
SourceRange R1, R2; |
| 47 |
StringRef Text1, Text2; |
| 48 |
Stmt *S; |
| 49 |
SmallVector<unsigned, 2> DiagIDs; |
| 50 |
}; |
| 51 |
|
| 52 |
std::vector<ActionData> CachedActions; |
| 53 |
|
| 54 |
enum RangeComparison { |
| 55 |
Range_Before, |
| 56 |
Range_After, |
| 57 |
Range_Contains, |
| 58 |
Range_Contained, |
| 59 |
Range_ExtendsBegin, |
| 60 |
Range_ExtendsEnd |
| 61 |
}; |
| 62 |
|
| 63 |
/// A range to remove. It is a character range. |
| 64 |
struct CharRange { |
| 65 |
FullSourceLoc Begin, End; |
| 66 |
|
| 67 |
CharRange(CharSourceRange range, SourceManager &srcMgr, Preprocessor &PP) { |
| 68 |
SourceLocation beginLoc = range.getBegin(), endLoc = range.getEnd(); |
| 69 |
assert(beginLoc.isValid() && endLoc.isValid()); |
| 70 |
if (range.isTokenRange()) { |
| 71 |
Begin = FullSourceLoc(srcMgr.getExpansionLoc(beginLoc), srcMgr); |
| 72 |
End = FullSourceLoc(getLocForEndOfToken(endLoc, srcMgr, PP), srcMgr); |
| 73 |
} else { |
| 74 |
Begin = FullSourceLoc(srcMgr.getExpansionLoc(beginLoc), srcMgr); |
| 75 |
End = FullSourceLoc(srcMgr.getExpansionLoc(endLoc), srcMgr); |
| 76 |
} |
| 77 |
assert(Begin.isValid() && End.isValid()); |
| 78 |
} |
| 79 |
|
| 80 |
RangeComparison compareWith(const CharRange &RHS) const { |
| 81 |
if (End.isBeforeInTranslationUnitThan(RHS.Begin)) |
| 82 |
return Range_Before; |
| 83 |
if (RHS.End.isBeforeInTranslationUnitThan(Begin)) |
| 84 |
return Range_After; |
| 85 |
if (!Begin.isBeforeInTranslationUnitThan(RHS.Begin) && |
| 86 |
!RHS.End.isBeforeInTranslationUnitThan(End)) |
| 87 |
return Range_Contained; |
| 88 |
if (Begin.isBeforeInTranslationUnitThan(RHS.Begin) && |
| 89 |
RHS.End.isBeforeInTranslationUnitThan(End)) |
| 90 |
return Range_Contains; |
| 91 |
if (Begin.isBeforeInTranslationUnitThan(RHS.Begin)) |
| 92 |
return Range_ExtendsBegin; |
| 93 |
else |
| 94 |
return Range_ExtendsEnd; |
| 95 |
} |
| 96 |
|
| 97 |
static RangeComparison compare(SourceRange LHS, SourceRange RHS, |
| 98 |
SourceManager &SrcMgr, Preprocessor &PP) { |
| 99 |
return CharRange(CharSourceRange::getTokenRange(LHS), SrcMgr, PP) |
| 100 |
.compareWith(CharRange(CharSourceRange::getTokenRange(RHS), |
| 101 |
SrcMgr, PP)); |
| 102 |
} |
| 103 |
}; |
| 104 |
|
| 105 |
typedef SmallVector<StringRef, 2> TextsVec; |
| 106 |
typedef std::map<FullSourceLoc, TextsVec, FullSourceLoc::BeforeThanCompare> |
| 107 |
InsertsMap; |
| 108 |
InsertsMap Inserts; |
| 109 |
/// A list of ranges to remove. They are always sorted and they never |
| 110 |
/// intersect with each other. |
| 111 |
std::list<CharRange> Removals; |
| 112 |
|
| 113 |
llvm::DenseSet<Stmt *> StmtRemovals; |
| 114 |
|
| 115 |
std::vector<std::pair<CharRange, SourceLocation> > IndentationRanges; |
| 116 |
|
| 117 |
/// Keeps text passed to transformation methods. |
| 118 |
llvm::StringMap<bool> UniqueText; |
| 119 |
|
| 120 |
public: |
| 121 |
TransformActionsImpl(CapturedDiagList &capturedDiags, |
| 122 |
ASTContext &ctx, Preprocessor &PP) |
| 123 |
: CapturedDiags(capturedDiags), Ctx(ctx), PP(PP), IsInTransaction(false) { } |
| 124 |
|
| 125 |
ASTContext &getASTContext() { return Ctx; } |
| 126 |
|
| 127 |
void startTransaction(); |
| 128 |
bool commitTransaction(); |
| 129 |
void abortTransaction(); |
| 130 |
|
| 131 |
bool isInTransaction() const { return IsInTransaction; } |
| 132 |
|
| 133 |
void insert(SourceLocation loc, StringRef text); |
| 134 |
void insertAfterToken(SourceLocation loc, StringRef text); |
| 135 |
void remove(SourceRange range); |
| 136 |
void removeStmt(Stmt *S); |
| 137 |
void replace(SourceRange range, StringRef text); |
| 138 |
void replace(SourceRange range, SourceRange replacementRange); |
| 139 |
void replaceStmt(Stmt *S, StringRef text); |
| 140 |
void replaceText(SourceLocation loc, StringRef text, |
| 141 |
StringRef replacementText); |
| 142 |
void increaseIndentation(SourceRange range, |
| 143 |
SourceLocation parentIndent); |
| 144 |
|
| 145 |
bool clearDiagnostic(ArrayRef<unsigned> IDs, SourceRange range); |
| 146 |
|
| 147 |
void applyRewrites(TransformActions::RewriteReceiver &receiver); |
| 148 |
|
| 149 |
private: |
| 150 |
bool canInsert(SourceLocation loc); |
| 151 |
bool canInsertAfterToken(SourceLocation loc); |
| 152 |
bool canRemoveRange(SourceRange range); |
| 153 |
bool canReplaceRange(SourceRange range, SourceRange replacementRange); |
| 154 |
bool canReplaceText(SourceLocation loc, StringRef text); |
| 155 |
|
| 156 |
void commitInsert(SourceLocation loc, StringRef text); |
| 157 |
void commitInsertAfterToken(SourceLocation loc, StringRef text); |
| 158 |
void commitRemove(SourceRange range); |
| 159 |
void commitRemoveStmt(Stmt *S); |
| 160 |
void commitReplace(SourceRange range, SourceRange replacementRange); |
| 161 |
void commitReplaceText(SourceLocation loc, StringRef text, |
| 162 |
StringRef replacementText); |
| 163 |
void commitIncreaseIndentation(SourceRange range,SourceLocation parentIndent); |
| 164 |
void commitClearDiagnostic(ArrayRef<unsigned> IDs, SourceRange range); |
| 165 |
|
| 166 |
void addRemoval(CharSourceRange range); |
| 167 |
void addInsertion(SourceLocation loc, StringRef text); |
| 168 |
|
| 169 |
/// Stores text passed to the transformation methods to keep the string |
| 170 |
/// "alive". Since the vast majority of text will be the same, we also unique |
| 171 |
/// the strings using a StringMap. |
| 172 |
StringRef getUniqueText(StringRef text); |
| 173 |
|
| 174 |
/// Computes the source location just past the end of the token at |
| 175 |
/// the given source location. If the location points at a macro, the whole |
| 176 |
/// macro expansion is skipped. |
| 177 |
static SourceLocation getLocForEndOfToken(SourceLocation loc, |
| 178 |
SourceManager &SM,Preprocessor &PP); |
| 179 |
}; |
| 180 |
|
| 181 |
} // anonymous namespace |
| 182 |
|
| 183 |
void TransformActionsImpl::startTransaction() { |
| 184 |
assert(!IsInTransaction && |
| 185 |
"Cannot start a transaction in the middle of another one"); |
| 186 |
IsInTransaction = true; |
| 187 |
} |
| 188 |
|
| 189 |
bool TransformActionsImpl::commitTransaction() { |
| 190 |
assert(IsInTransaction && "No transaction started"); |
| 191 |
|
| 192 |
if (CachedActions.empty()) { |
| 193 |
IsInTransaction = false; |
| 194 |
return false; |
| 195 |
} |
| 196 |
|
| 197 |
// Verify that all actions are possible otherwise abort the whole transaction. |
| 198 |
bool AllActionsPossible = true; |
| 199 |
for (unsigned i = 0, e = CachedActions.size(); i != e; ++i) { |
| 200 |
ActionData &act = CachedActions[i]; |
| 201 |
switch (act.Kind) { |
| 202 |
case Act_Insert: |
| 203 |
if (!canInsert(act.Loc)) |
| 204 |
AllActionsPossible = false; |
| 205 |
break; |
| 206 |
case Act_InsertAfterToken: |
| 207 |
if (!canInsertAfterToken(act.Loc)) |
| 208 |
AllActionsPossible = false; |
| 209 |
break; |
| 210 |
case Act_Remove: |
| 211 |
if (!canRemoveRange(act.R1)) |
| 212 |
AllActionsPossible = false; |
| 213 |
break; |
| 214 |
case Act_RemoveStmt: |
| 215 |
assert(act.S); |
| 216 |
if (!canRemoveRange(act.S->getSourceRange())) |
| 217 |
AllActionsPossible = false; |
| 218 |
break; |
| 219 |
case Act_Replace: |
| 220 |
if (!canReplaceRange(act.R1, act.R2)) |
| 221 |
AllActionsPossible = false; |
| 222 |
break; |
| 223 |
case Act_ReplaceText: |
| 224 |
if (!canReplaceText(act.Loc, act.Text1)) |
| 225 |
AllActionsPossible = false; |
| 226 |
break; |
| 227 |
case Act_IncreaseIndentation: |
| 228 |
// This is not important, we don't care if it will fail. |
| 229 |
break; |
| 230 |
case Act_ClearDiagnostic: |
| 231 |
// We are just checking source rewrites. |
| 232 |
break; |
| 233 |
} |
| 234 |
if (!AllActionsPossible) |
| 235 |
break; |
| 236 |
} |
| 237 |
|
| 238 |
if (!AllActionsPossible) { |
| 239 |
abortTransaction(); |
| 240 |
return true; |
| 241 |
} |
| 242 |
|
| 243 |
for (unsigned i = 0, e = CachedActions.size(); i != e; ++i) { |
| 244 |
ActionData &act = CachedActions[i]; |
| 245 |
switch (act.Kind) { |
| 246 |
case Act_Insert: |
| 247 |
commitInsert(act.Loc, act.Text1); |
| 248 |
break; |
| 249 |
case Act_InsertAfterToken: |
| 250 |
commitInsertAfterToken(act.Loc, act.Text1); |
| 251 |
break; |
| 252 |
case Act_Remove: |
| 253 |
commitRemove(act.R1); |
| 254 |
break; |
| 255 |
case Act_RemoveStmt: |
| 256 |
commitRemoveStmt(act.S); |
| 257 |
break; |
| 258 |
case Act_Replace: |
| 259 |
commitReplace(act.R1, act.R2); |
| 260 |
break; |
| 261 |
case Act_ReplaceText: |
| 262 |
commitReplaceText(act.Loc, act.Text1, act.Text2); |
| 263 |
break; |
| 264 |
case Act_IncreaseIndentation: |
| 265 |
commitIncreaseIndentation(act.R1, act.Loc); |
| 266 |
break; |
| 267 |
case Act_ClearDiagnostic: |
| 268 |
commitClearDiagnostic(act.DiagIDs, act.R1); |
| 269 |
break; |
| 270 |
} |
| 271 |
} |
| 272 |
|
| 273 |
CachedActions.clear(); |
| 274 |
IsInTransaction = false; |
| 275 |
return false; |
| 276 |
} |
| 277 |
|
| 278 |
void TransformActionsImpl::abortTransaction() { |
| 279 |
assert(IsInTransaction && "No transaction started"); |
| 280 |
CachedActions.clear(); |
| 281 |
IsInTransaction = false; |
| 282 |
} |
| 283 |
|
| 284 |
void TransformActionsImpl::insert(SourceLocation loc, StringRef text) { |
| 285 |
assert(IsInTransaction && "Actions only allowed during a transaction"); |
| 286 |
text = getUniqueText(text); |
| 287 |
ActionData data; |
| 288 |
data.Kind = Act_Insert; |
| 289 |
data.Loc = loc; |
| 290 |
data.Text1 = text; |
| 291 |
CachedActions.push_back(data); |
| 292 |
} |
| 293 |
|
| 294 |
void TransformActionsImpl::insertAfterToken(SourceLocation loc, StringRef text) { |
| 295 |
assert(IsInTransaction && "Actions only allowed during a transaction"); |
| 296 |
text = getUniqueText(text); |
| 297 |
ActionData data; |
| 298 |
data.Kind = Act_InsertAfterToken; |
| 299 |
data.Loc = loc; |
| 300 |
data.Text1 = text; |
| 301 |
CachedActions.push_back(data); |
| 302 |
} |
| 303 |
|
| 304 |
void TransformActionsImpl::remove(SourceRange range) { |
| 305 |
assert(IsInTransaction && "Actions only allowed during a transaction"); |
| 306 |
ActionData data; |
| 307 |
data.Kind = Act_Remove; |
| 308 |
data.R1 = range; |
| 309 |
CachedActions.push_back(data); |
| 310 |
} |
| 311 |
|
| 312 |
void TransformActionsImpl::removeStmt(Stmt *S) { |
| 313 |
assert(IsInTransaction && "Actions only allowed during a transaction"); |
| 314 |
ActionData data; |
| 315 |
data.Kind = Act_RemoveStmt; |
| 316 |
if (auto *E = dyn_cast<Expr>(S)) |
| 317 |
S = E->IgnoreImplicit(); // important for uniquing |
| 318 |
data.S = S; |
| 319 |
CachedActions.push_back(data); |
| 320 |
} |
| 321 |
|
| 322 |
void TransformActionsImpl::replace(SourceRange range, StringRef text) { |
| 323 |
assert(IsInTransaction && "Actions only allowed during a transaction"); |
| 324 |
text = getUniqueText(text); |
| 325 |
remove(range); |
| 326 |
insert(range.getBegin(), text); |
| 327 |
} |
| 328 |
|
| 329 |
void TransformActionsImpl::replace(SourceRange range, |
| 330 |
SourceRange replacementRange) { |
| 331 |
assert(IsInTransaction && "Actions only allowed during a transaction"); |
| 332 |
ActionData data; |
| 333 |
data.Kind = Act_Replace; |
| 334 |
data.R1 = range; |
| 335 |
data.R2 = replacementRange; |
| 336 |
CachedActions.push_back(data); |
| 337 |
} |
| 338 |
|
| 339 |
void TransformActionsImpl::replaceText(SourceLocation loc, StringRef text, |
| 340 |
StringRef replacementText) { |
| 341 |
text = getUniqueText(text); |
| 342 |
replacementText = getUniqueText(replacementText); |
| 343 |
ActionData data; |
| 344 |
data.Kind = Act_ReplaceText; |
| 345 |
data.Loc = loc; |
| 346 |
data.Text1 = text; |
| 347 |
data.Text2 = replacementText; |
| 348 |
CachedActions.push_back(data); |
| 349 |
} |
| 350 |
|
| 351 |
void TransformActionsImpl::replaceStmt(Stmt *S, StringRef text) { |
| 352 |
assert(IsInTransaction && "Actions only allowed during a transaction"); |
| 353 |
text = getUniqueText(text); |
| 354 |
insert(S->getBeginLoc(), text); |
| 355 |
removeStmt(S); |
| 356 |
} |
| 357 |
|
| 358 |
void TransformActionsImpl::increaseIndentation(SourceRange range, |
| 359 |
SourceLocation parentIndent) { |
| 360 |
if (range.isInvalid()) return; |
| 361 |
assert(IsInTransaction && "Actions only allowed during a transaction"); |
| 362 |
ActionData data; |
| 363 |
data.Kind = Act_IncreaseIndentation; |
| 364 |
data.R1 = range; |
| 365 |
data.Loc = parentIndent; |
| 366 |
CachedActions.push_back(data); |
| 367 |
} |
| 368 |
|
| 369 |
bool TransformActionsImpl::clearDiagnostic(ArrayRef<unsigned> IDs, |
| 370 |
SourceRange range) { |
| 371 |
assert(IsInTransaction && "Actions only allowed during a transaction"); |
| 372 |
if (!CapturedDiags.hasDiagnostic(IDs, range)) |
| 373 |
return false; |
| 374 |
|
| 375 |
ActionData data; |
| 376 |
data.Kind = Act_ClearDiagnostic; |
| 377 |
data.R1 = range; |
| 378 |
data.DiagIDs.append(IDs.begin(), IDs.end()); |
| 379 |
CachedActions.push_back(data); |
| 380 |
return true; |
| 381 |
} |
| 382 |
|
| 383 |
bool TransformActionsImpl::canInsert(SourceLocation loc) { |
| 384 |
if (loc.isInvalid()) |
| 385 |
return false; |
| 386 |
|
| 387 |
SourceManager &SM = Ctx.getSourceManager(); |
| 388 |
if (SM.isInSystemHeader(SM.getExpansionLoc(loc))) |
| 389 |
return false; |
| 390 |
|
| 391 |
if (loc.isFileID()) |
| 392 |
return true; |
| 393 |
return PP.isAtStartOfMacroExpansion(loc); |
| 394 |
} |
| 395 |
|
| 396 |
bool TransformActionsImpl::canInsertAfterToken(SourceLocation loc) { |
| 397 |
if (loc.isInvalid()) |
| 398 |
return false; |
| 399 |
|
| 400 |
SourceManager &SM = Ctx.getSourceManager(); |
| 401 |
if (SM.isInSystemHeader(SM.getExpansionLoc(loc))) |
| 402 |
return false; |
| 403 |
|
| 404 |
if (loc.isFileID()) |
| 405 |
return true; |
| 406 |
return PP.isAtEndOfMacroExpansion(loc); |
| 407 |
} |
| 408 |
|
| 409 |
bool TransformActionsImpl::canRemoveRange(SourceRange range) { |
| 410 |
return canInsert(range.getBegin()) && canInsertAfterToken(range.getEnd()); |
| 411 |
} |
| 412 |
|
| 413 |
bool TransformActionsImpl::canReplaceRange(SourceRange range, |
| 414 |
SourceRange replacementRange) { |
| 415 |
return canRemoveRange(range) && canRemoveRange(replacementRange); |
| 416 |
} |
| 417 |
|
| 418 |
bool TransformActionsImpl::canReplaceText(SourceLocation loc, StringRef text) { |
| 419 |
if (!canInsert(loc)) |
| 420 |
return false; |
| 421 |
|
| 422 |
SourceManager &SM = Ctx.getSourceManager(); |
| 423 |
loc = SM.getExpansionLoc(loc); |
| 424 |
|
| 425 |
// Break down the source location. |
| 426 |
std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc); |
| 427 |
|
| 428 |
// Try to load the file buffer. |
| 429 |
bool invalidTemp = false; |
| 430 |
StringRef file = SM.getBufferData(locInfo.first, &invalidTemp); |
| 431 |
if (invalidTemp) |
| 432 |
return false; |
| 433 |
|
| 434 |
return file.substr(locInfo.second).startswith(text); |
| 435 |
} |
| 436 |
|
| 437 |
void TransformActionsImpl::commitInsert(SourceLocation loc, StringRef text) { |
| 438 |
addInsertion(loc, text); |
| 439 |
} |
| 440 |
|
| 441 |
void TransformActionsImpl::commitInsertAfterToken(SourceLocation loc, |
| 442 |
StringRef text) { |
| 443 |
addInsertion(getLocForEndOfToken(loc, Ctx.getSourceManager(), PP), text); |
| 444 |
} |
| 445 |
|
| 446 |
void TransformActionsImpl::commitRemove(SourceRange range) { |
| 447 |
addRemoval(CharSourceRange::getTokenRange(range)); |
| 448 |
} |
| 449 |
|
| 450 |
void TransformActionsImpl::commitRemoveStmt(Stmt *S) { |
| 451 |
assert(S); |
| 452 |
if (StmtRemovals.count(S)) |
| 453 |
return; // already removed. |
| 454 |
|
| 455 |
if (Expr *E = dyn_cast<Expr>(S)) { |
| 456 |
commitRemove(E->getSourceRange()); |
| 457 |
commitInsert(E->getSourceRange().getBegin(), getARCMTMacroName()); |
| 458 |
} else |
| 459 |
commitRemove(S->getSourceRange()); |
| 460 |
|
| 461 |
StmtRemovals.insert(S); |
| 462 |
} |
| 463 |
|
| 464 |
void TransformActionsImpl::commitReplace(SourceRange range, |
| 465 |
SourceRange replacementRange) { |
| 466 |
RangeComparison comp = CharRange::compare(replacementRange, range, |
| 467 |
Ctx.getSourceManager(), PP); |
| 468 |
assert(comp == Range_Contained); |
| 469 |
if (comp != Range_Contained) |
| 470 |
return; // Although we asserted, be extra safe for release build. |
| 471 |
if (range.getBegin() != replacementRange.getBegin()) |
| 472 |
addRemoval(CharSourceRange::getCharRange(range.getBegin(), |
| 473 |
replacementRange.getBegin())); |
| 474 |
if (replacementRange.getEnd() != range.getEnd()) |
| 475 |
addRemoval(CharSourceRange::getTokenRange( |
| 476 |
getLocForEndOfToken(replacementRange.getEnd(), |
| 477 |
Ctx.getSourceManager(), PP), |
| 478 |
range.getEnd())); |
| 479 |
} |
| 480 |
void TransformActionsImpl::commitReplaceText(SourceLocation loc, |
| 481 |
StringRef text, |
| 482 |
StringRef replacementText) { |
| 483 |
SourceManager &SM = Ctx.getSourceManager(); |
| 484 |
loc = SM.getExpansionLoc(loc); |
| 485 |
// canReplaceText already checked if loc points at text. |
| 486 |
SourceLocation afterText = loc.getLocWithOffset(text.size()); |
| 487 |
|
| 488 |
addRemoval(CharSourceRange::getCharRange(loc, afterText)); |
| 489 |
commitInsert(loc, replacementText); |
| 490 |
} |
| 491 |
|
| 492 |
void TransformActionsImpl::commitIncreaseIndentation(SourceRange range, |
| 493 |
SourceLocation parentIndent) { |
| 494 |
SourceManager &SM = Ctx.getSourceManager(); |
| 495 |
IndentationRanges.push_back( |
| 496 |
std::make_pair(CharRange(CharSourceRange::getTokenRange(range), |
| 497 |
SM, PP), |
| 498 |
SM.getExpansionLoc(parentIndent))); |
| 499 |
} |
| 500 |
|
| 501 |
void TransformActionsImpl::commitClearDiagnostic(ArrayRef<unsigned> IDs, |
| 502 |
SourceRange range) { |
| 503 |
CapturedDiags.clearDiagnostic(IDs, range); |
| 504 |
} |
| 505 |
|
| 506 |
void TransformActionsImpl::addInsertion(SourceLocation loc, StringRef text) { |
| 507 |
SourceManager &SM = Ctx.getSourceManager(); |
| 508 |
loc = SM.getExpansionLoc(loc); |
| 509 |
for (const CharRange &I : llvm::reverse(Removals)) { |
| 510 |
if (!SM.isBeforeInTranslationUnit(loc, I.End)) |
| 511 |
break; |
| 512 |
if (I.Begin.isBeforeInTranslationUnitThan(loc)) |
| 513 |
return; |
| 514 |
} |
| 515 |
|
| 516 |
Inserts[FullSourceLoc(loc, SM)].push_back(text); |
| 517 |
} |
| 518 |
|
| 519 |
void TransformActionsImpl::addRemoval(CharSourceRange range) { |
| 520 |
CharRange newRange(range, Ctx.getSourceManager(), PP); |
| 521 |
if (newRange.Begin == newRange.End) |
| 522 |
return; |
| 523 |
|
| 524 |
Inserts.erase(Inserts.upper_bound(newRange.Begin), |
| 525 |
Inserts.lower_bound(newRange.End)); |
| 526 |
|
| 527 |
std::list<CharRange>::iterator I = Removals.end(); |
| 528 |
while (I != Removals.begin()) { |
| 529 |
std::list<CharRange>::iterator RI = I; |
| 530 |
--RI; |
| 531 |
RangeComparison comp = newRange.compareWith(*RI); |
| 532 |
switch (comp) { |
| 533 |
case Range_Before: |
| 534 |
--I; |
| 535 |
break; |
| 536 |
case Range_After: |
| 537 |
Removals.insert(I, newRange); |
| 538 |
return; |
| 539 |
case Range_Contained: |
| 540 |
return; |
| 541 |
case Range_Contains: |
| 542 |
RI->End = newRange.End; |
| 543 |
[[fallthrough]]; |
| 544 |
case Range_ExtendsBegin: |
| 545 |
newRange.End = RI->End; |
| 546 |
Removals.erase(RI); |
| 547 |
break; |
| 548 |
case Range_ExtendsEnd: |
| 549 |
RI->End = newRange.End; |
| 550 |
return; |
| 551 |
} |
| 552 |
} |
| 553 |
|
| 554 |
Removals.insert(Removals.begin(), newRange); |
| 555 |
} |
| 556 |
|
| 557 |
void TransformActionsImpl::applyRewrites( |
| 558 |
TransformActions::RewriteReceiver &receiver) { |
| 559 |
for (InsertsMap::iterator I = Inserts.begin(), E = Inserts.end(); I!=E; ++I) { |
| 560 |
SourceLocation loc = I->first; |
| 561 |
for (TextsVec::iterator |
| 562 |
TI = I->second.begin(), TE = I->second.end(); TI != TE; ++TI) { |
| 563 |
receiver.insert(loc, *TI); |
| 564 |
} |
| 565 |
} |
| 566 |
|
| 567 |
for (std::vector<std::pair<CharRange, SourceLocation> >::iterator |
| 568 |
I = IndentationRanges.begin(), E = IndentationRanges.end(); I!=E; ++I) { |
| 569 |
CharSourceRange range = CharSourceRange::getCharRange(I->first.Begin, |
| 570 |
I->first.End); |
| 571 |
receiver.increaseIndentation(range, I->second); |
| 572 |
} |
| 573 |
|
| 574 |
for (std::list<CharRange>::iterator |
| 575 |
I = Removals.begin(), E = Removals.end(); I != E; ++I) { |
| 576 |
CharSourceRange range = CharSourceRange::getCharRange(I->Begin, I->End); |
| 577 |
receiver.remove(range); |
| 578 |
} |
| 579 |
} |
| 580 |
|
| 581 |
/// Stores text passed to the transformation methods to keep the string |
| 582 |
/// "alive". Since the vast majority of text will be the same, we also unique |
| 583 |
/// the strings using a StringMap. |
| 584 |
StringRef TransformActionsImpl::getUniqueText(StringRef text) { |
| 585 |
return UniqueText.insert(std::make_pair(text, false)).first->first(); |
| 586 |
} |
| 587 |
|
| 588 |
/// Computes the source location just past the end of the token at |
| 589 |
/// the given source location. If the location points at a macro, the whole |
| 590 |
/// macro expansion is skipped. |
| 591 |
SourceLocation TransformActionsImpl::getLocForEndOfToken(SourceLocation loc, |
| 592 |
SourceManager &SM, |
| 593 |
Preprocessor &PP) { |
| 594 |
if (loc.isMacroID()) { |
| 595 |
CharSourceRange Exp = SM.getExpansionRange(loc); |
| 596 |
if (Exp.isCharRange()) |
| 597 |
return Exp.getEnd(); |
| 598 |
loc = Exp.getEnd(); |
| 599 |
} |
| 600 |
return PP.getLocForEndOfToken(loc); |
| 601 |
} |
| 602 |
|
| 603 |
TransformActions::RewriteReceiver::~RewriteReceiver() { } |
| 604 |
|
| 605 |
TransformActions::TransformActions(DiagnosticsEngine &diag, |
| 606 |
CapturedDiagList &capturedDiags, |
| 607 |
ASTContext &ctx, Preprocessor &PP) |
| 608 |
: Diags(diag), CapturedDiags(capturedDiags) { |
| 609 |
Impl = new TransformActionsImpl(capturedDiags, ctx, PP); |
| 610 |
} |
| 611 |
|
| 612 |
TransformActions::~TransformActions() { |
| 613 |
delete static_cast<TransformActionsImpl*>(Impl); |
| 614 |
} |
| 615 |
|
| 616 |
void TransformActions::startTransaction() { |
| 617 |
static_cast<TransformActionsImpl*>(Impl)->startTransaction(); |
| 618 |
} |
| 619 |
|
| 620 |
bool TransformActions::commitTransaction() { |
| 621 |
return static_cast<TransformActionsImpl*>(Impl)->commitTransaction(); |
| 622 |
} |
| 623 |
|
| 624 |
void TransformActions::abortTransaction() { |
| 625 |
static_cast<TransformActionsImpl*>(Impl)->abortTransaction(); |
| 626 |
} |
| 627 |
|
| 628 |
|
| 629 |
void TransformActions::insert(SourceLocation loc, StringRef text) { |
| 630 |
static_cast<TransformActionsImpl*>(Impl)->insert(loc, text); |
| 631 |
} |
| 632 |
|
| 633 |
void TransformActions::insertAfterToken(SourceLocation loc, |
| 634 |
StringRef text) { |
| 635 |
static_cast<TransformActionsImpl*>(Impl)->insertAfterToken(loc, text); |
| 636 |
} |
| 637 |
|
| 638 |
void TransformActions::remove(SourceRange range) { |
| 639 |
static_cast<TransformActionsImpl*>(Impl)->remove(range); |
| 640 |
} |
| 641 |
|
| 642 |
void TransformActions::removeStmt(Stmt *S) { |
| 643 |
static_cast<TransformActionsImpl*>(Impl)->removeStmt(S); |
| 644 |
} |
| 645 |
|
| 646 |
void TransformActions::replace(SourceRange range, StringRef text) { |
| 647 |
static_cast<TransformActionsImpl*>(Impl)->replace(range, text); |
| 648 |
} |
| 649 |
|
| 650 |
void TransformActions::replace(SourceRange range, |
| 651 |
SourceRange replacementRange) { |
| 652 |
static_cast<TransformActionsImpl*>(Impl)->replace(range, replacementRange); |
| 653 |
} |
| 654 |
|
| 655 |
void TransformActions::replaceStmt(Stmt *S, StringRef text) { |
| 656 |
static_cast<TransformActionsImpl*>(Impl)->replaceStmt(S, text); |
| 657 |
} |
| 658 |
|
| 659 |
void TransformActions::replaceText(SourceLocation loc, StringRef text, |
| 660 |
StringRef replacementText) { |
| 661 |
static_cast<TransformActionsImpl*>(Impl)->replaceText(loc, text, |
| 662 |
replacementText); |
| 663 |
} |
| 664 |
|
| 665 |
void TransformActions::increaseIndentation(SourceRange range, |
| 666 |
SourceLocation parentIndent) { |
| 667 |
static_cast<TransformActionsImpl*>(Impl)->increaseIndentation(range, |
| 668 |
parentIndent); |
| 669 |
} |
| 670 |
|
| 671 |
bool TransformActions::clearDiagnostic(ArrayRef<unsigned> IDs, |
| 672 |
SourceRange range) { |
| 673 |
return static_cast<TransformActionsImpl*>(Impl)->clearDiagnostic(IDs, range); |
| 674 |
} |
| 675 |
|
| 676 |
void TransformActions::applyRewrites(RewriteReceiver &receiver) { |
| 677 |
static_cast<TransformActionsImpl*>(Impl)->applyRewrites(receiver); |
| 678 |
} |
| 679 |
|
| 680 |
DiagnosticBuilder TransformActions::report(SourceLocation loc, unsigned diagId, |
| 681 |
SourceRange range) { |
| 682 |
assert(!static_cast<TransformActionsImpl *>(Impl)->isInTransaction() && |
| 683 |
"Errors should be emitted out of a transaction"); |
| 684 |
return Diags.Report(loc, diagId) << range; |
| 685 |
} |
| 686 |
|
| 687 |
void TransformActions::reportError(StringRef message, SourceLocation loc, |
| 688 |
SourceRange range) { |
| 689 |
report(loc, diag::err_mt_message, range) << message; |
| 690 |
} |
| 691 |
|
| 692 |
void TransformActions::reportWarning(StringRef message, SourceLocation loc, |
| 693 |
SourceRange range) { |
| 694 |
report(loc, diag::warn_mt_message, range) << message; |
| 695 |
} |
| 696 |
|
| 697 |
void TransformActions::reportNote(StringRef message, SourceLocation loc, |
| 698 |
SourceRange range) { |
| 699 |
report(loc, diag::note_mt_message, range) << message; |
| 700 |
} |