Home | History | Annotate | Download | only in Edit 
      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 void EditedSource::deconstructMacroArgLoc(SourceLocation Loc,
     27                                           SourceLocation &ExpansionLoc,
     28                                           IdentifierInfo *&II) {
     29   assert(SourceMgr.isMacroArgExpansion(Loc));
     30   SourceLocation DefArgLoc = SourceMgr.getImmediateExpansionRange(Loc).first;
     31   ExpansionLoc = SourceMgr.getImmediateExpansionRange(DefArgLoc).first;
     32   SmallString<20> Buf;
     33   StringRef ArgName = Lexer::getSpelling(SourceMgr.getSpellingLoc(DefArgLoc),
     34                                          Buf, SourceMgr, LangOpts);
     35   II = nullptr;
     36   if (!ArgName.empty()) {
     37     II = &IdentTable.get(ArgName);
     38   }
     39 }
     40 
     41 void EditedSource::startingCommit() {}
     42 
     43 void EditedSource::finishedCommit() {
     44   for (auto &ExpArg : CurrCommitMacroArgExps) {
     45     SourceLocation ExpLoc;
     46     IdentifierInfo *II;
     47     std::tie(ExpLoc, II) = ExpArg;
     48     auto &ArgNames = ExpansionToArgMap[ExpLoc.getRawEncoding()];
     49     if (std::find(ArgNames.begin(), ArgNames.end(), II) == ArgNames.end()) {
     50       ArgNames.push_back(II);
     51     }
     52   }
     53   CurrCommitMacroArgExps.clear();
     54 }
     55 
     56 StringRef EditedSource::copyString(const Twine &twine) {
     57   SmallString<128> Data;
     58   return copyString(twine.toStringRef(Data));
     59 }
     60 
     61 bool EditedSource::canInsertInOffset(SourceLocation OrigLoc, FileOffset Offs) {
     62   FileEditsTy::iterator FA = getActionForOffset(Offs);
     63   if (FA != FileEdits.end()) {
     64     if (FA->first != Offs)
     65       return false; // position has been removed.
     66   }
     67 
     68   if (SourceMgr.isMacroArgExpansion(OrigLoc)) {
     69     IdentifierInfo *II;
     70     SourceLocation ExpLoc;
     71     deconstructMacroArgLoc(OrigLoc, ExpLoc, II);
     72     auto I = ExpansionToArgMap.find(ExpLoc.getRawEncoding());
     73     if (I != ExpansionToArgMap.end() &&
     74         std::find(I->second.begin(), I->second.end(), II) != I->second.end()) {
     75       // Trying to write in a macro argument input that has already been
     76       // written by a previous commit for another expansion of the same macro
     77       // argument name. For example:
     78       //
     79       // \code
     80       //   #define MAC(x) ((x)+(x))
     81       //   MAC(a)
     82       // \endcode
     83       //
     84       // A commit modified the macro argument 'a' due to the first '(x)'
     85       // expansion inside the macro definition, and a subsequent commit tried
     86       // to modify 'a' again for the second '(x)' expansion. The edits of the
     87       // second commit will be rejected.
     88       return false;
     89     }
     90   }
     91 
     92   return true;
     93 }
     94 
     95 bool EditedSource::commitInsert(SourceLocation OrigLoc,
     96                                 FileOffset Offs, StringRef text,
     97                                 bool beforePreviousInsertions) {
     98   if (!canInsertInOffset(OrigLoc, Offs))
     99     return false;
    100   if (text.empty())
    101     return true;
    102 
    103   if (SourceMgr.isMacroArgExpansion(OrigLoc)) {
    104     IdentifierInfo *II;
    105     SourceLocation ExpLoc;
    106     deconstructMacroArgLoc(OrigLoc, ExpLoc, II);
    107     if (II)
    108       CurrCommitMacroArgExps.emplace_back(ExpLoc, II);
    109   }
    110 
    111   FileEdit &FA = FileEdits[Offs];
    112   if (FA.Text.empty()) {
    113     FA.Text = copyString(text);
    114     return true;
    115   }
    116 
    117   if (beforePreviousInsertions)
    118     FA.Text = copyString(Twine(text) + FA.Text);
    119   else
    120     FA.Text = copyString(Twine(FA.Text) + text);
    121 
    122   return true;
    123 }
    124 
    125 bool EditedSource::commitInsertFromRange(SourceLocation OrigLoc,
    126                                    FileOffset Offs,
    127                                    FileOffset InsertFromRangeOffs, unsigned Len,
    128                                    bool beforePreviousInsertions) {
    129   if (Len == 0)
    130     return true;
    131 
    132   SmallString<128> StrVec;
    133   FileOffset BeginOffs = InsertFromRangeOffs;
    134   FileOffset EndOffs = BeginOffs.getWithOffset(Len);
    135   FileEditsTy::iterator I = FileEdits.upper_bound(BeginOffs);
    136   if (I != FileEdits.begin())
    137     --I;
    138 
    139   for (; I != FileEdits.end(); ++I) {
    140     FileEdit &FA = I->second;
    141     FileOffset B = I->first;
    142     FileOffset E = B.getWithOffset(FA.RemoveLen);
    143 
    144     if (BeginOffs == B)
    145       break;
    146 
    147     if (BeginOffs < E) {
    148       if (BeginOffs > B) {
    149         BeginOffs = E;
    150         ++I;
    151       }
    152       break;
    153     }
    154   }
    155 
    156   for (; I != FileEdits.end() && EndOffs > I->first; ++I) {
    157     FileEdit &FA = I->second;
    158     FileOffset B = I->first;
    159     FileOffset E = B.getWithOffset(FA.RemoveLen);
    160 
    161     if (BeginOffs < B) {
    162       bool Invalid = false;
    163       StringRef text = getSourceText(BeginOffs, B, Invalid);
    164       if (Invalid)
    165         return false;
    166       StrVec += text;
    167     }
    168     StrVec += FA.Text;
    169     BeginOffs = E;
    170   }
    171 
    172   if (BeginOffs < EndOffs) {
    173     bool Invalid = false;
    174     StringRef text = getSourceText(BeginOffs, EndOffs, Invalid);
    175     if (Invalid)
    176       return false;
    177     StrVec += text;
    178   }
    179 
    180   return commitInsert(OrigLoc, Offs, StrVec, beforePreviousInsertions);
    181 }
    182 
    183 void EditedSource::commitRemove(SourceLocation OrigLoc,
    184                                 FileOffset BeginOffs, unsigned Len) {
    185   if (Len == 0)
    186     return;
    187 
    188   FileOffset EndOffs = BeginOffs.getWithOffset(Len);
    189   FileEditsTy::iterator I = FileEdits.upper_bound(BeginOffs);
    190   if (I != FileEdits.begin())
    191     --I;
    192 
    193   for (; I != FileEdits.end(); ++I) {
    194     FileEdit &FA = I->second;
    195     FileOffset B = I->first;
    196     FileOffset E = B.getWithOffset(FA.RemoveLen);
    197 
    198     if (BeginOffs < E)
    199       break;
    200   }
    201 
    202   FileOffset TopBegin, TopEnd;
    203   FileEdit *TopFA = nullptr;
    204 
    205   if (I == FileEdits.end()) {
    206     FileEditsTy::iterator
    207       NewI = FileEdits.insert(I, std::make_pair(BeginOffs, FileEdit()));
    208     NewI->second.RemoveLen = Len;
    209     return;
    210   }
    211 
    212   FileEdit &FA = I->second;
    213   FileOffset B = I->first;
    214   FileOffset E = B.getWithOffset(FA.RemoveLen);
    215   if (BeginOffs < B) {
    216     FileEditsTy::iterator
    217       NewI = FileEdits.insert(I, std::make_pair(BeginOffs, FileEdit()));
    218     TopBegin = BeginOffs;
    219     TopEnd = EndOffs;
    220     TopFA = &NewI->second;
    221     TopFA->RemoveLen = Len;
    222   } else {
    223     TopBegin = B;
    224     TopEnd = E;
    225     TopFA = &I->second;
    226     if (TopEnd >= EndOffs)
    227       return;
    228     unsigned diff = EndOffs.getOffset() - TopEnd.getOffset();
    229     TopEnd = EndOffs;
    230     TopFA->RemoveLen += diff;
    231     if (B == BeginOffs)
    232       TopFA->Text = StringRef();
    233     ++I;
    234   }
    235 
    236   while (I != FileEdits.end()) {
    237     FileEdit &FA = I->second;
    238     FileOffset B = I->first;
    239     FileOffset E = B.getWithOffset(FA.RemoveLen);
    240 
    241     if (B >= TopEnd)
    242       break;
    243 
    244     if (E <= TopEnd) {
    245       FileEdits.erase(I++);
    246       continue;
    247     }
    248 
    249     if (B < TopEnd) {
    250       unsigned diff = E.getOffset() - TopEnd.getOffset();
    251       TopEnd = E;
    252       TopFA->RemoveLen += diff;
    253       FileEdits.erase(I);
    254     }
    255 
    256     break;
    257   }
    258 }
    259 
    260 bool EditedSource::commit(const Commit &commit) {
    261   if (!commit.isCommitable())
    262     return false;
    263 
    264   struct CommitRAII {
    265     EditedSource &Editor;
    266     CommitRAII(EditedSource &Editor) : Editor(Editor) {
    267       Editor.startingCommit();
    268     }
    269     ~CommitRAII() {
    270       Editor.finishedCommit();
    271     }
    272   } CommitRAII(*this);
    273 
    274   for (edit::Commit::edit_iterator
    275          I = commit.edit_begin(), E = commit.edit_end(); I != E; ++I) {
    276     const edit::Commit::Edit &edit = *I;
    277     switch (edit.Kind) {
    278     case edit::Commit::Act_Insert:
    279       commitInsert(edit.OrigLoc, edit.Offset, edit.Text, edit.BeforePrev);
    280       break;
    281     case edit::Commit::Act_InsertFromRange:
    282       commitInsertFromRange(edit.OrigLoc, edit.Offset,
    283                             edit.InsertFromRangeOffs, edit.Length,
    284                             edit.BeforePrev);
    285       break;
    286     case edit::Commit::Act_Remove:
    287       commitRemove(edit.OrigLoc, edit.Offset, edit.Length);
    288       break;
    289     }
    290   }
    291 
    292   return true;
    293 }
    294 
    295 // \brief Returns true if it is ok to make the two given characters adjacent.
    296 static bool canBeJoined(char left, char right, const LangOptions &LangOpts) {
    297   // FIXME: Should use TokenConcatenation to make sure we don't allow stuff like
    298   // making two '<' adjacent.
    299   return !(Lexer::isIdentifierBodyChar(left, LangOpts) &&
    300            Lexer::isIdentifierBodyChar(right, LangOpts));
    301 }
    302 
    303 /// \brief Returns true if it is ok to eliminate the trailing whitespace between
    304 /// the given characters.
    305 static bool canRemoveWhitespace(char left, char beforeWSpace, char right,
    306                                 const LangOptions &LangOpts) {
    307   if (!canBeJoined(left, right, LangOpts))
    308     return false;
    309   if (isWhitespace(left) || isWhitespace(right))
    310     return true;
    311   if (canBeJoined(beforeWSpace, right, LangOpts))
    312     return false; // the whitespace was intentional, keep it.
    313   return true;
    314 }
    315 
    316 /// \brief Check the range that we are going to remove and:
    317 /// -Remove any trailing whitespace if possible.
    318 /// -Insert a space if removing the range is going to mess up the source tokens.
    319 static void adjustRemoval(const SourceManager &SM, const LangOptions &LangOpts,
    320                           SourceLocation Loc, FileOffset offs,
    321                           unsigned &len, StringRef &text) {
    322   assert(len && text.empty());
    323   SourceLocation BeginTokLoc = Lexer::GetBeginningOfToken(Loc, SM, LangOpts);
    324   if (BeginTokLoc != Loc)
    325     return; // the range is not at the beginning of a token, keep the range.
    326 
    327   bool Invalid = false;
    328   StringRef buffer = SM.getBufferData(offs.getFID(), &Invalid);
    329   if (Invalid)
    330     return;
    331 
    332   unsigned begin = offs.getOffset();
    333   unsigned end = begin + len;
    334 
    335   // Do not try to extend the removal if we're at the end of the buffer already.
    336   if (end == buffer.size())
    337     return;
    338 
    339   assert(begin < buffer.size() && end < buffer.size() && "Invalid range!");
    340 
    341   // FIXME: Remove newline.
    342 
    343   if (begin == 0) {
    344     if (buffer[end] == ' ')
    345       ++len;
    346     return;
    347   }
    348 
    349   if (buffer[end] == ' ') {
    350     assert((end + 1 != buffer.size() || buffer.data()[end + 1] == 0) &&
    351            "buffer not zero-terminated!");
    352     if (canRemoveWhitespace(/*left=*/buffer[begin-1],
    353                             /*beforeWSpace=*/buffer[end-1],
    354                             /*right=*/buffer.data()[end + 1], // zero-terminated
    355                             LangOpts))
    356       ++len;
    357     return;
    358   }
    359 
    360   if (!canBeJoined(buffer[begin-1], buffer[end], LangOpts))
    361     text = " ";
    362 }
    363 
    364 static void applyRewrite(EditsReceiver &receiver,
    365                          StringRef text, FileOffset offs, unsigned len,
    366                          const SourceManager &SM, const LangOptions &LangOpts) {
    367   assert(offs.getFID().isValid());
    368   SourceLocation Loc = SM.getLocForStartOfFile(offs.getFID());
    369   Loc = Loc.getLocWithOffset(offs.getOffset());
    370   assert(Loc.isFileID());
    371 
    372   if (text.empty())
    373     adjustRemoval(SM, LangOpts, Loc, offs, len, text);
    374 
    375   CharSourceRange range = CharSourceRange::getCharRange(Loc,
    376                                                      Loc.getLocWithOffset(len));
    377 
    378   if (text.empty()) {
    379     assert(len);
    380     receiver.remove(range);
    381     return;
    382   }
    383 
    384   if (len)
    385     receiver.replace(range, text);
    386   else
    387     receiver.insert(Loc, text);
    388 }
    389 
    390 void EditedSource::applyRewrites(EditsReceiver &receiver) {
    391   SmallString<128> StrVec;
    392   FileOffset CurOffs, CurEnd;
    393   unsigned CurLen;
    394 
    395   if (FileEdits.empty())
    396     return;
    397 
    398   FileEditsTy::iterator I = FileEdits.begin();
    399   CurOffs = I->first;
    400   StrVec = I->second.Text;
    401   CurLen = I->second.RemoveLen;
    402   CurEnd = CurOffs.getWithOffset(CurLen);
    403   ++I;
    404 
    405   for (FileEditsTy::iterator E = FileEdits.end(); I != E; ++I) {
    406     FileOffset offs = I->first;
    407     FileEdit act = I->second;
    408     assert(offs >= CurEnd);
    409 
    410     if (offs == CurEnd) {
    411       StrVec += act.Text;
    412       CurLen += act.RemoveLen;
    413       CurEnd.getWithOffset(act.RemoveLen);
    414       continue;
    415     }
    416 
    417     applyRewrite(receiver, StrVec, CurOffs, CurLen, SourceMgr, LangOpts);
    418     CurOffs = offs;
    419     StrVec = act.Text;
    420     CurLen = act.RemoveLen;
    421     CurEnd = CurOffs.getWithOffset(CurLen);
    422   }
    423 
    424   applyRewrite(receiver, StrVec, CurOffs, CurLen, SourceMgr, LangOpts);
    425 }
    426 
    427 void EditedSource::clearRewrites() {
    428   FileEdits.clear();
    429   StrAlloc.Reset();
    430 }
    431 
    432 StringRef EditedSource::getSourceText(FileOffset BeginOffs, FileOffset EndOffs,
    433                                       bool &Invalid) {
    434   assert(BeginOffs.getFID() == EndOffs.getFID());
    435   assert(BeginOffs <= EndOffs);
    436   SourceLocation BLoc = SourceMgr.getLocForStartOfFile(BeginOffs.getFID());
    437   BLoc = BLoc.getLocWithOffset(BeginOffs.getOffset());
    438   assert(BLoc.isFileID());
    439   SourceLocation
    440     ELoc = BLoc.getLocWithOffset(EndOffs.getOffset() - BeginOffs.getOffset());
    441   return Lexer::getSourceText(CharSourceRange::getCharRange(BLoc, ELoc),
    442                               SourceMgr, LangOpts, &Invalid);
    443 }
    444 
    445 EditedSource::FileEditsTy::iterator
    446 EditedSource::getActionForOffset(FileOffset Offs) {
    447   FileEditsTy::iterator I = FileEdits.upper_bound(Offs);
    448   if (I == FileEdits.begin())
    449     return FileEdits.end();
    450   --I;
    451   FileEdit &FA = I->second;
    452   FileOffset B = I->first;
    453   FileOffset E = B.getWithOffset(FA.RemoveLen);
    454   if (Offs >= B && Offs < E)
    455     return I;
    456 
    457   return FileEdits.end();
    458 }
    459