clang/lib/Edit/Commit.cpp

   1 //===- Commit.cpp - A unit of edits ---------------------------------------===//
   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 "clang/Edit/Commit.h"
  10 #include "clang/Basic/LLVM.h"
  11 #include "clang/Basic/SourceLocation.h"
  12 #include "clang/Basic/SourceManager.h"
  13 #include "clang/Edit/EditedSource.h"
  14 #include "clang/Edit/FileOffset.h"
  15 #include "clang/Lex/Lexer.h"
  16 #include "clang/Lex/PPConditionalDirectiveRecord.h"
  17 #include "llvm/ADT/StringRef.h"
  18 #include <cassert>
  19 #include <utility>
  20
  21 using namespace clang;
  22 using namespace edit;
  23
  24 SourceLocation Commit::Edit::getFileLocation(SourceManager &SM) const {
  25   SourceLocation Loc = SM.getLocForStartOfFile(Offset.getFID());
  26   Loc = Loc.getLocWithOffset(Offset.getOffset());
  27   assert(Loc.isFileID());
  28   return Loc;
  29 }
  30
  31 CharSourceRange Commit::Edit::getFileRange(SourceManager &SM) const {
  32   SourceLocation Loc = getFileLocation(SM);
  33   return CharSourceRange::getCharRange(Loc, Loc.getLocWithOffset(Length));
  34 }
  35
  36 CharSourceRange Commit::Edit::getInsertFromRange(SourceManager &SM) const {
  37   SourceLocation Loc = SM.getLocForStartOfFile(InsertFromRangeOffs.getFID());
  38   Loc = Loc.getLocWithOffset(InsertFromRangeOffs.getOffset());
  39   assert(Loc.isFileID());
  40   return CharSourceRange::getCharRange(Loc, Loc.getLocWithOffset(Length));
  41 }
  42
  43 Commit::Commit(EditedSource &Editor)
  44     : SourceMgr(Editor.getSourceManager()), LangOpts(Editor.getLangOpts()),
  45       PPRec(Editor.getPPCondDirectiveRecord()),
  46       Editor(&Editor) {}
  47
  48 bool Commit::insert(SourceLocation loc, StringRef text,
  49                     bool afterToken, bool beforePreviousInsertions) {
  50   if (text.empty())
  51     return true;
  52
  53   FileOffset Offs;
  54   if ((!afterToken && !canInsert(loc, Offs)) ||
  55       ( afterToken && !canInsertAfterToken(loc, Offs, loc))) {
  56     IsCommitable = false;
  57     return false;
  58   }
  59
  60   addInsert(loc, Offs, text, beforePreviousInsertions);
  61   return true;
  62 }
  63
  64 bool Commit::insertFromRange(SourceLocation loc,
  65                              CharSourceRange range,
  66                              bool afterToken, bool beforePreviousInsertions) {
  67   FileOffset RangeOffs;
  68   unsigned RangeLen;
  69   if (!canRemoveRange(range, RangeOffs, RangeLen)) {
  70     IsCommitable = false;
  71     return false;
  72   }
  73
  74   FileOffset Offs;
  75   if ((!afterToken && !canInsert(loc, Offs)) ||
  76       ( afterToken && !canInsertAfterToken(loc, Offs, loc))) {
  77     IsCommitable = false;
  78     return false;
  79   }
  80
  81   if (PPRec &&
  82       PPRec->areInDifferentConditionalDirectiveRegion(loc, range.getBegin())) {
  83     IsCommitable = false;
  84     return false;
  85   }
  86
  87   addInsertFromRange(loc, Offs, RangeOffs, RangeLen, beforePreviousInsertions);
  88   return true;
  89 }
  90
  91 bool Commit::remove(CharSourceRange range) {
  92   FileOffset Offs;
  93   unsigned Len;
  94   if (!canRemoveRange(range, Offs, Len)) {
  95     IsCommitable = false;
  96     return false;
  97   }
  98
  99   addRemove(range.getBegin(), Offs, Len);
 100   return true;
 101 }
 102
 103 bool Commit::insertWrap(StringRef before, CharSourceRange range,
 104                         StringRef after) {
 105   bool commitableBefore = insert(range.getBegin(), before, /*afterToken=*/false,
 106                                  /*beforePreviousInsertions=*/true);
 107   bool commitableAfter;
 108   if (range.isTokenRange())
 109     commitableAfter = insertAfterToken(range.getEnd(), after);
 110   else
 111     commitableAfter = insert(range.getEnd(), after);
 112
 113   return commitableBefore && commitableAfter;
 114 }
 115
 116 bool Commit::replace(CharSourceRange range, StringRef text) {
 117   if (text.empty())
 118     return remove(range);
 119
 120   FileOffset Offs;
 121   unsigned Len;
 122   if (!canInsert(range.getBegin(), Offs) || !canRemoveRange(range, Offs, Len)) {
 123     IsCommitable = false;
 124     return false;
 125   }
 126
 127   addRemove(range.getBegin(), Offs, Len);
 128   addInsert(range.getBegin(), Offs, text, false);
 129   return true;
 130 }
 131
 132 bool Commit::replaceWithInner(CharSourceRange range,
 133                               CharSourceRange replacementRange) {
 134   FileOffset OuterBegin;
 135   unsigned OuterLen;
 136   if (!canRemoveRange(range, OuterBegin, OuterLen)) {
 137     IsCommitable = false;
 138     return false;
 139   }
 140
 141   FileOffset InnerBegin;
 142   unsigned InnerLen;
 143   if (!canRemoveRange(replacementRange, InnerBegin, InnerLen)) {
 144     IsCommitable = false;
 145     return false;
 146   }
 147
 148   FileOffset OuterEnd = OuterBegin.getWithOffset(OuterLen);
 149   FileOffset InnerEnd = InnerBegin.getWithOffset(InnerLen);
 150   if (OuterBegin.getFID() != InnerBegin.getFID() ||
 151       InnerBegin < OuterBegin ||
 152       InnerBegin > OuterEnd ||
 153       InnerEnd > OuterEnd) {
 154     IsCommitable = false;
 155     return false;
 156   }
 157
 158   addRemove(range.getBegin(),
 159             OuterBegin, InnerBegin.getOffset() - OuterBegin.getOffset());
 160   addRemove(replacementRange.getEnd(),
 161             InnerEnd, OuterEnd.getOffset() - InnerEnd.getOffset());
 162   return true;
 163 }
 164
 165 bool Commit::replaceText(SourceLocation loc, StringRef text,
 166                          StringRef replacementText) {
 167   if (text.empty() || replacementText.empty())
 168     return true;
 169
 170   FileOffset Offs;
 171   unsigned Len;
 172   if (!canReplaceText(loc, replacementText, Offs, Len)) {
 173     IsCommitable = false;
 174     return false;
 175   }
 176
 177   addRemove(loc, Offs, Len);
 178   addInsert(loc, Offs, text, false);
 179   return true;
 180 }
 181
 182 void Commit::addInsert(SourceLocation OrigLoc, FileOffset Offs, StringRef text,
 183                        bool beforePreviousInsertions) {
 184   if (text.empty())
 185     return;
 186
 187   Edit data;
 188   data.Kind = Act_Insert;
 189   data.OrigLoc = OrigLoc;
 190   data.Offset = Offs;
 191   data.Text = text.copy(StrAlloc);
 192   data.BeforePrev = beforePreviousInsertions;
 193   CachedEdits.push_back(data);
 194 }
 195
 196 void Commit::addInsertFromRange(SourceLocation OrigLoc, FileOffset Offs,
 197                                 FileOffset RangeOffs, unsigned RangeLen,
 198                                 bool beforePreviousInsertions) {
 199   if (RangeLen == 0)
 200     return;
 201
 202   Edit data;
 203   data.Kind = Act_InsertFromRange;
 204   data.OrigLoc = OrigLoc;
 205   data.Offset = Offs;
 206   data.InsertFromRangeOffs = RangeOffs;
 207   data.Length = RangeLen;
 208   data.BeforePrev = beforePreviousInsertions;
 209   CachedEdits.push_back(data);
 210 }
 211
 212 void Commit::addRemove(SourceLocation OrigLoc,
 213                        FileOffset Offs, unsigned Len) {
 214   if (Len == 0)
 215     return;
 216
 217   Edit data;
 218   data.Kind = Act_Remove;
 219   data.OrigLoc = OrigLoc;
 220   data.Offset = Offs;
 221   data.Length = Len;
 222   CachedEdits.push_back(data);
 223 }
 224
 225 bool Commit::canInsert(SourceLocation loc, FileOffset &offs) {
 226   if (loc.isInvalid())
 227     return false;
 228
 229   if (loc.isMacroID())
 230     isAtStartOfMacroExpansion(loc, &loc);
 231
 232   const SourceManager &SM = SourceMgr;
 233   loc = SM.getTopMacroCallerLoc(loc);
 234
 235   if (loc.isMacroID())
 236     if (!isAtStartOfMacroExpansion(loc, &loc))
 237       return false;
 238
 239   if (SM.isInSystemHeader(loc))
 240     return false;
 241
 242   std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc);
 243   if (locInfo.first.isInvalid())
 244     return false;
 245   offs = FileOffset(locInfo.first, locInfo.second);
 246   return canInsertInOffset(loc, offs);
 247 }
 248
 249 bool Commit::canInsertAfterToken(SourceLocation loc, FileOffset &offs,
 250                                  SourceLocation &AfterLoc) {
 251   if (loc.isInvalid())
 252
 253     return false;
 254
 255   SourceLocation spellLoc = SourceMgr.getSpellingLoc(loc);
 256   unsigned tokLen = Lexer::MeasureTokenLength(spellLoc, SourceMgr, LangOpts);
 257   AfterLoc = loc.getLocWithOffset(tokLen);
 258
 259   if (loc.isMacroID())
 260     isAtEndOfMacroExpansion(loc, &loc);
 261
 262   const SourceManager &SM = SourceMgr;
 263   loc = SM.getTopMacroCallerLoc(loc);
 264
 265   if (loc.isMacroID())
 266     if (!isAtEndOfMacroExpansion(loc, &loc))
 267       return false;
 268
 269   if (SM.isInSystemHeader(loc))
 270     return false;
 271
 272   loc = Lexer::getLocForEndOfToken(loc, 0, SourceMgr, LangOpts);
 273   if (loc.isInvalid())
 274     return false;
 275
 276   std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc);
 277   if (locInfo.first.isInvalid())
 278     return false;
 279   offs = FileOffset(locInfo.first, locInfo.second);
 280   return canInsertInOffset(loc, offs);
 281 }
 282
 283 bool Commit::canInsertInOffset(SourceLocation OrigLoc, FileOffset Offs) {
 284   for (const auto &act : CachedEdits)
 285     if (act.Kind == Act_Remove) {
 286       if (act.Offset.getFID() == Offs.getFID() &&
 287           Offs > act.Offset && Offs < act.Offset.getWithOffset(act.Length))
 288         return false; // position has been removed.
 289     }
 290
 291   if (!Editor)
 292     return true;
 293   return Editor->canInsertInOffset(OrigLoc, Offs);
 294 }
 295
 296 bool Commit::canRemoveRange(CharSourceRange range,
 297                             FileOffset &Offs, unsigned &Len) {
 298   const SourceManager &SM = SourceMgr;
 299   range = Lexer::makeFileCharRange(range, SM, LangOpts);
 300   if (range.isInvalid())
 301     return false;
 302
 303   if (range.getBegin().isMacroID() || range.getEnd().isMacroID())
 304     return false;
 305   if (SM.isInSystemHeader(range.getBegin()) ||
 306       SM.isInSystemHeader(range.getEnd()))
 307     return false;
 308
 309   if (PPRec && PPRec->rangeIntersectsConditionalDirective(range.getAsRange()))
 310     return false;
 311
 312   std::pair<FileID, unsigned> beginInfo = SM.getDecomposedLoc(range.getBegin());
 313   std::pair<FileID, unsigned> endInfo = SM.getDecomposedLoc(range.getEnd());
 314   if (beginInfo.first != endInfo.first ||
 315       beginInfo.second > endInfo.second)
 316     return false;
 317
 318   Offs = FileOffset(beginInfo.first, beginInfo.second);
 319   Len = endInfo.second - beginInfo.second;
 320   return true;
 321 }
 322
 323 bool Commit::canReplaceText(SourceLocation loc, StringRef text,
 324                             FileOffset &Offs, unsigned &Len) {
 325   assert(!text.empty());
 326
 327   if (!canInsert(loc, Offs))
 328     return false;
 329
 330   // Try to load the file buffer.
 331   bool invalidTemp = false;
 332   StringRef file = SourceMgr.getBufferData(Offs.getFID(), &invalidTemp);
 333   if (invalidTemp)
 334     return false;
 335
 336   Len = text.size();
 337   return file.substr(Offs.getOffset()).startswith(text);
 338 }
 339
 340 bool Commit::isAtStartOfMacroExpansion(SourceLocation loc,
 341                                        SourceLocation *MacroBegin) const {
 342   return Lexer::isAtStartOfMacroExpansion(loc, SourceMgr, LangOpts, MacroBegin);
 343 }
 344
 345 bool Commit::isAtEndOfMacroExpansion(SourceLocation loc,
 346                                      SourceLocation *MacroEnd) const {
 347   return Lexer::isAtEndOfMacroExpansion(loc, SourceMgr, LangOpts, MacroEnd);
 348 }