[clang-diff] Split source ranges at points where nodes are inserted.

[johannes]

Summary

This enables inserting into empty CompoundStmt nodes, for example.
Previously the insertion would occur only after the closing parenthesis.

lib/Tooling/ASTDiff/ASTPatch.cpp

public:
   Optional<std::string> OwnText;
 
   PatchedTreeNode(NodeRef BaseNode) : BaseNode(BaseNode) {}
   PatchedTreeNode(const PatchedTreeNode &Other) = delete;
   PatchedTreeNode(PatchedTreeNode &&Other) = default;
 
   void addInsertion(PatchedTreeNode &PatchedNode, SourceLocation InsertionLoc) {
     addChildAt(PatchedNode, InsertionLoc);
+    SplitAt.emplace_back(InsertionLoc);
   }
   void addChild(PatchedTreeNode &PatchedNode) {
     SourceLocation InsertionLoc = PatchedNode.getSourceRange().getBegin();
     addChildAt(PatchedNode, InsertionLoc);
   }
 
+  // This returns an array of source ranges identical to the input,
+  // except whenever a SourceRange contains any of the locations in
+  // SplitAt, it is split up in two ranges at that location.
+  SmallVector<CharSourceRange, 4>
+  splitSourceRanges(ArrayRef<CharSourceRange> SourceRanges);
+
 private:
   void addChildAt(PatchedTreeNode &PatchedNode, SourceLocation InsertionLoc) {
     auto Less = makeTolerantLess(getTree().getSourceManager());
     auto It = std::lower_bound(ChildrenLocations.begin(),
                                ChildrenLocations.end(), InsertionLoc, Less);
     auto Offset = It - ChildrenLocations.begin();
     Children.insert(Children.begin() + Offset, &PatchedNode);
     ChildrenLocations.insert(It, InsertionLoc);
   }
+
+  SmallVector<SourceLocation, 2> SplitAt;
 };
 } // end anonymous namespace
 
 namespace {
 class Patcher {
   SyntaxTree &Dst, &Target;
   SourceManager &SM;
   const LangOptions &LangOpts;
void Patcher::setOwnedSourceText(PatchedTreeNode &PatchedNode) {
   if (isFromTarget(PatchedNode)) {
     SrcNode = TargetDiff.getMapped(PatchedNode);
     ChangeKind Change = SrcNode ? Diff.getNodeChange(*SrcNode) : NoChange;
     IsUpdate = Change == Update || Change == UpdateMove;
   }
   unsigned ChildIndex = 0;
   auto MySourceRanges = PatchedNode.getOwnedSourceRanges();
   BeforeThanCompare<SourceLocation> MyLess(Tree.getSourceManager());
-  for (auto &MySubRange : MySourceRanges) {
+  for (auto &MySubRange : PatchedNode.splitSourceRanges(MySourceRanges)) {
     SourceLocation ChildBegin;
     SourceLocation InsertionBegin;
     while (ChildIndex < NumChildren &&
            ((ChildBegin = ChildrenLocations[ChildIndex]).isInvalid() ||
             wantToInsertBefore(ChildBegin, MySubRange.getEnd(), MyLess))) {
       ChildrenOffsets.push_back(OwnText->size());
       ++ChildIndex;
     }
for (unsigned I = 0; I < NumChildren; ++I) {
     }
     if (Less(MyLoc, SiblingLoc)) {
       return {I, /*RightOfSibling=*/false};
     }
   }
   return {-1, true};
 }
 
+static bool onlyWhitespace(StringRef Str) {
+  return std::all_of(Str.begin(), Str.end(),
+                     [](char C) { return std::isspace(C); });
+}
+
+SmallVector<CharSourceRange, 4>
+PatchedTreeNode::splitSourceRanges(ArrayRef<CharSourceRange> SourceRanges) {
+  SourceManager &SM = getTree().getSourceManager();
+  const LangOptions &LangOpts = getTree().getLangOpts();
+  SmallVector<CharSourceRange, 4> Result;
+  BeforeThanCompare<SourceLocation> Less(SM);
+  std::sort(SplitAt.begin(), SplitAt.end(), Less);
+  for (auto &Range : SourceRanges) {
+    SourceLocation Begin = Range.getBegin(), End = Range.getEnd();
+    for (auto SplitPoint : SplitAt) {
+      if (SM.isPointWithin(SplitPoint, Begin, End)) {
+        auto SplitRange = CharSourceRange::getCharRange(Begin, SplitPoint);
+        StringRef Text = Lexer::getSourceText(SplitRange, SM, LangOpts);
+        if (onlyWhitespace(Text))
+          continue;
+        Result.emplace_back(SplitRange);
+        Begin = SplitPoint;
+      }
+    }
+    if (Less(Begin, End))
+      Result.emplace_back(CharSourceRange::getCharRange(Begin, End));
+  }
+  return Result;
+}
+
 Error patch(RefactoringTool &TargetTool, SyntaxTree &Src, SyntaxTree &Dst,
             const ComparisonOptions &Options, bool Debug) {
   std::vector<std::unique_ptr<ASTUnit>> TargetASTs;
   TargetTool.buildASTs(TargetASTs);
   if (TargetASTs.size() != 1)
     return error(patching_error::failed_to_build_AST);
   SyntaxTree Target(*TargetASTs[0]);
   return Patcher(Src, Dst, Target, Options, TargetTool, Debug).apply();

unittests/Tooling/ASTPatchTest.cpp

PATCH(R"(class A { int x; };)",
         R"(class A { int y; };)",
         R"(class A { int y; };)");
 }
 TEST_F(ASTPatchTest, UpdateMove) {
   PATCH(R"(void f() { { int x = 1; } })",
         R"(void f() { })",
         R"(void f() { { int x = 2; } })",
         R"(void f() {  })");
+  PATCH(R"(void f() {;;} namespace {})",
+        R"(namespace { void f() {;;} })",
+        R"(void g() {;;} namespace {})",
+        R"(namespace { void g() {;;} })");
 }