contrib/llvm/tools/clang/lib/Edit/EditedSource.cpp

   1 //===----- EditedSource.cpp - Collection of source edits ------------------===//
   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 #include "clang/Edit/EditedSource.h"
  11 #include "clang/Basic/CharInfo.h"
  12 #include "clang/Basic/SourceManager.h"
  13 #include "clang/Edit/Commit.h"
  14 #include "clang/Edit/EditsReceiver.h"
  15 #include "clang/Lex/Lexer.h"
  16 #include "llvm/ADT/SmallString.h"
  17 #include "llvm/ADT/Twine.h"
  18
  19 using namespace clang;
  20 using namespace edit;
  21
  22 void EditsReceiver::remove(CharSourceRange range) {
  23   replace(range, StringRef());
  24 }
  25
  26 StringRef EditedSource::copyString(const Twine &twine) {
  27   SmallString<128> Data;
  28   return copyString(twine.toStringRef(Data));
  29 }
  30
  31 bool EditedSource::canInsertInOffset(SourceLocation OrigLoc, FileOffset Offs) {
  32   FileEditsTy::iterator FA = getActionForOffset(Offs);
  33   if (FA != FileEdits.end()) {
  34     if (FA->first != Offs)
  35       return false; // position has been removed.
  36   }
  37
  38   if (SourceMgr.isMacroArgExpansion(OrigLoc)) {
  39     SourceLocation
  40       DefArgLoc = SourceMgr.getImmediateExpansionRange(OrigLoc).first;
  41     SourceLocation
  42       ExpLoc = SourceMgr.getImmediateExpansionRange(DefArgLoc).first;
  43     llvm::DenseMap<unsigned, SourceLocation>::iterator
  44       I = ExpansionToArgMap.find(ExpLoc.getRawEncoding());
  45     if (I != ExpansionToArgMap.end() && I->second != DefArgLoc)
  46       return false; // Trying to write in a macro argument input that has
  47                  // already been written for another argument of the same macro.
  48   }
  49
  50   return true;
  51 }
  52
  53 bool EditedSource::commitInsert(SourceLocation OrigLoc,
  54                                 FileOffset Offs, StringRef text,
  55                                 bool beforePreviousInsertions) {
  56   if (!canInsertInOffset(OrigLoc, Offs))
  57     return false;
  58   if (text.empty())
  59     return true;
  60
  61   if (SourceMgr.isMacroArgExpansion(OrigLoc)) {
  62     SourceLocation
  63       DefArgLoc = SourceMgr.getImmediateExpansionRange(OrigLoc).first;
  64     SourceLocation
  65       ExpLoc = SourceMgr.getImmediateExpansionRange(DefArgLoc).first;
  66     ExpansionToArgMap[ExpLoc.getRawEncoding()] = DefArgLoc;
  67   }
  68
  69   FileEdit &FA = FileEdits[Offs];
  70   if (FA.Text.empty()) {
  71     FA.Text = copyString(text);
  72     return true;
  73   }
  74
  75   Twine concat;
  76   if (beforePreviousInsertions)
  77     concat = Twine(text) + FA.Text;
  78   else
  79     concat = Twine(FA.Text) +  text;
  80
  81   FA.Text = copyString(concat);
  82   return true;
  83 }
  84
  85 bool EditedSource::commitInsertFromRange(SourceLocation OrigLoc,
  86                                    FileOffset Offs,
  87                                    FileOffset InsertFromRangeOffs, unsigned Len,
  88                                    bool beforePreviousInsertions) {
  89   if (Len == 0)
  90     return true;
  91
  92   SmallString<128> StrVec;
  93   FileOffset BeginOffs = InsertFromRangeOffs;
  94   FileOffset EndOffs = BeginOffs.getWithOffset(Len);
  95   FileEditsTy::iterator I = FileEdits.upper_bound(BeginOffs);
  96   if (I != FileEdits.begin())
  97     --I;
  98
  99   for (; I != FileEdits.end(); ++I) {
 100     FileEdit &FA = I->second;
 101     FileOffset B = I->first;
 102     FileOffset E = B.getWithOffset(FA.RemoveLen);
 103
 104     if (BeginOffs == B)
 105       break;
 106
 107     if (BeginOffs < E) {
 108       if (BeginOffs > B) {
 109         BeginOffs = E;
 110         ++I;
 111       }
 112       break;
 113     }
 114   }
 115
 116   for (; I != FileEdits.end() && EndOffs > I->first; ++I) {
 117     FileEdit &FA = I->second;
 118     FileOffset B = I->first;
 119     FileOffset E = B.getWithOffset(FA.RemoveLen);
 120
 121     if (BeginOffs < B) {
 122       bool Invalid = false;
 123       StringRef text = getSourceText(BeginOffs, B, Invalid);
 124       if (Invalid)
 125         return false;
 126       StrVec += text;
 127     }
 128     StrVec += FA.Text;
 129     BeginOffs = E;
 130   }
 131
 132   if (BeginOffs < EndOffs) {
 133     bool Invalid = false;
 134     StringRef text = getSourceText(BeginOffs, EndOffs, Invalid);
 135     if (Invalid)
 136       return false;
 137     StrVec += text;
 138   }
 139
 140   return commitInsert(OrigLoc, Offs, StrVec.str(), beforePreviousInsertions);
 141 }
 142
 143 void EditedSource::commitRemove(SourceLocation OrigLoc,
 144                                 FileOffset BeginOffs, unsigned Len) {
 145   if (Len == 0)
 146     return;
 147
 148   FileOffset EndOffs = BeginOffs.getWithOffset(Len);
 149   FileEditsTy::iterator I = FileEdits.upper_bound(BeginOffs);
 150   if (I != FileEdits.begin())
 151     --I;
 152
 153   for (; I != FileEdits.end(); ++I) {
 154     FileEdit &FA = I->second;
 155     FileOffset B = I->first;
 156     FileOffset E = B.getWithOffset(FA.RemoveLen);
 157
 158     if (BeginOffs < E)
 159       break;
 160   }
 161
 162   FileOffset TopBegin, TopEnd;
 163   FileEdit *TopFA = 0;
 164
 165   if (I == FileEdits.end()) {
 166     FileEditsTy::iterator
 167       NewI = FileEdits.insert(I, std::make_pair(BeginOffs, FileEdit()));
 168     NewI->second.RemoveLen = Len;
 169     return;
 170   }
 171
 172   FileEdit &FA = I->second;
 173   FileOffset B = I->first;
 174   FileOffset E = B.getWithOffset(FA.RemoveLen);
 175   if (BeginOffs < B) {
 176     FileEditsTy::iterator
 177       NewI = FileEdits.insert(I, std::make_pair(BeginOffs, FileEdit()));
 178     TopBegin = BeginOffs;
 179     TopEnd = EndOffs;
 180     TopFA = &NewI->second;
 181     TopFA->RemoveLen = Len;
 182   } else {
 183     TopBegin = B;
 184     TopEnd = E;
 185     TopFA = &I->second;
 186     if (TopEnd >= EndOffs)
 187       return;
 188     unsigned diff = EndOffs.getOffset() - TopEnd.getOffset();
 189     TopEnd = EndOffs;
 190     TopFA->RemoveLen += diff;
 191     if (B == BeginOffs)
 192       TopFA->Text = StringRef();
 193     ++I;
 194   }
 195
 196   while (I != FileEdits.end()) {
 197     FileEdit &FA = I->second;
 198     FileOffset B = I->first;
 199     FileOffset E = B.getWithOffset(FA.RemoveLen);
 200
 201     if (B >= TopEnd)
 202       break;
 203
 204     if (E <= TopEnd) {
 205       FileEdits.erase(I++);
 206       continue;
 207     }
 208
 209     if (B < TopEnd) {
 210       unsigned diff = E.getOffset() - TopEnd.getOffset();
 211       TopEnd = E;
 212       TopFA->RemoveLen += diff;
 213       FileEdits.erase(I);
 214     }
 215
 216     break;
 217   }
 218 }
 219
 220 bool EditedSource::commit(const Commit &commit) {
 221   if (!commit.isCommitable())
 222     return false;
 223
 224   for (edit::Commit::edit_iterator
 225          I = commit.edit_begin(), E = commit.edit_end(); I != E; ++I) {
 226     const edit::Commit::Edit &edit = *I;
 227     switch (edit.Kind) {
 228     case edit::Commit::Act_Insert:
 229       commitInsert(edit.OrigLoc, edit.Offset, edit.Text, edit.BeforePrev);
 230       break;
 231     case edit::Commit::Act_InsertFromRange:
 232       commitInsertFromRange(edit.OrigLoc, edit.Offset,
 233                             edit.InsertFromRangeOffs, edit.Length,
 234                             edit.BeforePrev);
 235       break;
 236     case edit::Commit::Act_Remove:
 237       commitRemove(edit.OrigLoc, edit.Offset, edit.Length);
 238       break;
 239     }
 240   }
 241
 242   return true;
 243 }
 244
 245 // \brief Returns true if it is ok to make the two given characters adjacent.
 246 static bool canBeJoined(char left, char right, const LangOptions &LangOpts) {
 247   // FIXME: Should use TokenConcatenation to make sure we don't allow stuff like
 248   // making two '<' adjacent.
 249   return !(Lexer::isIdentifierBodyChar(left, LangOpts) &&
 250            Lexer::isIdentifierBodyChar(right, LangOpts));
 251 }
 252
 253 /// \brief Returns true if it is ok to eliminate the trailing whitespace between
 254 /// the given characters.
 255 static bool canRemoveWhitespace(char left, char beforeWSpace, char right,
 256                                 const LangOptions &LangOpts) {
 257   if (!canBeJoined(left, right, LangOpts))
 258     return false;
 259   if (isWhitespace(left) || isWhitespace(right))
 260     return true;
 261   if (canBeJoined(beforeWSpace, right, LangOpts))
 262     return false; // the whitespace was intentional, keep it.
 263   return true;
 264 }
 265
 266 /// \brief Check the range that we are going to remove and:
 267 /// -Remove any trailing whitespace if possible.
 268 /// -Insert a space if removing the range is going to mess up the source tokens.
 269 static void adjustRemoval(const SourceManager &SM, const LangOptions &LangOpts,
 270                           SourceLocation Loc, FileOffset offs,
 271                           unsigned &len, StringRef &text) {
 272   assert(len && text.empty());
 273   SourceLocation BeginTokLoc = Lexer::GetBeginningOfToken(Loc, SM, LangOpts);
 274   if (BeginTokLoc != Loc)
 275     return; // the range is not at the beginning of a token, keep the range.
 276
 277   bool Invalid = false;
 278   StringRef buffer = SM.getBufferData(offs.getFID(), &Invalid);
 279   if (Invalid)
 280     return;
 281
 282   unsigned begin = offs.getOffset();
 283   unsigned end = begin + len;
 284
 285   // FIXME: Remove newline.
 286
 287   if (begin == 0) {
 288     if (buffer[end] == ' ')
 289       ++len;
 290     return;
 291   }
 292
 293   if (buffer[end] == ' ') {
 294     if (canRemoveWhitespace(/*left=*/buffer[begin-1],
 295                             /*beforeWSpace=*/buffer[end-1],
 296                             /*right=*/buffer[end+1],
 297                             LangOpts))
 298       ++len;
 299     return;
 300   }
 301
 302   if (!canBeJoined(buffer[begin-1], buffer[end], LangOpts))
 303     text = " ";
 304 }
 305
 306 static void applyRewrite(EditsReceiver &receiver,
 307                          StringRef text, FileOffset offs, unsigned len,
 308                          const SourceManager &SM, const LangOptions &LangOpts) {
 309   assert(!offs.getFID().isInvalid());
 310   SourceLocation Loc = SM.getLocForStartOfFile(offs.getFID());
 311   Loc = Loc.getLocWithOffset(offs.getOffset());
 312   assert(Loc.isFileID());
 313
 314   if (text.empty())
 315     adjustRemoval(SM, LangOpts, Loc, offs, len, text);
 316
 317   CharSourceRange range = CharSourceRange::getCharRange(Loc,
 318                                                      Loc.getLocWithOffset(len));
 319
 320   if (text.empty()) {
 321     assert(len);
 322     receiver.remove(range);
 323     return;
 324   }
 325
 326   if (len)
 327     receiver.replace(range, text);
 328   else
 329     receiver.insert(Loc, text);
 330 }
 331
 332 void EditedSource::applyRewrites(EditsReceiver &receiver) {
 333   SmallString<128> StrVec;
 334   FileOffset CurOffs, CurEnd;
 335   unsigned CurLen;
 336
 337   if (FileEdits.empty())
 338     return;
 339
 340   FileEditsTy::iterator I = FileEdits.begin();
 341   CurOffs = I->first;
 342   StrVec = I->second.Text;
 343   CurLen = I->second.RemoveLen;
 344   CurEnd = CurOffs.getWithOffset(CurLen);
 345   ++I;
 346
 347   for (FileEditsTy::iterator E = FileEdits.end(); I != E; ++I) {
 348     FileOffset offs = I->first;
 349     FileEdit act = I->second;
 350     assert(offs >= CurEnd);
 351
 352     if (offs == CurEnd) {
 353       StrVec += act.Text;
 354       CurLen += act.RemoveLen;
 355       CurEnd.getWithOffset(act.RemoveLen);
 356       continue;
 357     }
 358
 359     applyRewrite(receiver, StrVec.str(), CurOffs, CurLen, SourceMgr, LangOpts);
 360     CurOffs = offs;
 361     StrVec = act.Text;
 362     CurLen = act.RemoveLen;
 363     CurEnd = CurOffs.getWithOffset(CurLen);
 364   }
 365
 366   applyRewrite(receiver, StrVec.str(), CurOffs, CurLen, SourceMgr, LangOpts);
 367 }
 368
 369 void EditedSource::clearRewrites() {
 370   FileEdits.clear();
 371   StrAlloc.Reset();
 372 }
 373
 374 StringRef EditedSource::getSourceText(FileOffset BeginOffs, FileOffset EndOffs,
 375                                       bool &Invalid) {
 376   assert(BeginOffs.getFID() == EndOffs.getFID());
 377   assert(BeginOffs <= EndOffs);
 378   SourceLocation BLoc = SourceMgr.getLocForStartOfFile(BeginOffs.getFID());
 379   BLoc = BLoc.getLocWithOffset(BeginOffs.getOffset());
 380   assert(BLoc.isFileID());
 381   SourceLocation
 382     ELoc = BLoc.getLocWithOffset(EndOffs.getOffset() - BeginOffs.getOffset());
 383   return Lexer::getSourceText(CharSourceRange::getCharRange(BLoc, ELoc),
 384                               SourceMgr, LangOpts, &Invalid);
 385 }
 386
 387 EditedSource::FileEditsTy::iterator
 388 EditedSource::getActionForOffset(FileOffset Offs) {
 389   FileEditsTy::iterator I = FileEdits.upper_bound(Offs);
 390   if (I == FileEdits.begin())
 391     return FileEdits.end();
 392   --I;
 393   FileEdit &FA = I->second;
 394   FileOffset B = I->first;
 395   FileOffset E = B.getWithOffset(FA.RemoveLen);
 396   if (Offs >= B && Offs < E)
 397     return I;
 398
 399   return FileEdits.end();
 400 }