[clang-diff] Expose Node::getSourceRange()

include/clang/Tooling/ASTDiff/ASTDiff.h

struct Node {
   llvm::Optional<StringRef> getIdentifier() const;
   llvm::Optional<std::string> getQualifiedIdentifier() const;
 
   NodeRefIterator begin() const;
   NodeRefIterator end() const;
 
   int findPositionInParent() const;
 
-  // Returns the starting and ending offset of the node in its source file.
+  /// Returns the range that contains the text that is associated with this
+  /// node. This is based on DynTypedNode::getSourceRange() with a couple of
+  /// workarounds.
+  ///
+  /// The range for statements includes the trailing semicolon.
+  ///
+  /// The range for implicit ThisExpression nodes is empty.
+  ///
+  /// If it is a CXXConstructExpr that is not a temporary, then we exclude
+  /// the class name from the range by returning
+  /// CXXConstructExpr::getParentOrBraceRange(). So the class name will belong
+  /// to the parent.
+  CharSourceRange getSourceRange() const;
+
+  /// Returns the offsets for the range returned by getSourceRange().
   std::pair<unsigned, unsigned> getSourceRangeOffsets() const;
 };
 
 struct NodeRefIterator {
   SyntaxTree::Impl *Tree;
   const NodeId *IdPointer;
   NodeRefIterator(SyntaxTree::Impl *Tree, const NodeId *IdPointer)
       : Tree(Tree), IdPointer(IdPointer) {}

lib/Tooling/ASTDiff/ASTDiff.cpp

if (!SM.isInMainFile(SLoc))
       return true;
     const Preprocessor &PP = AST.getPreprocessor();
     if (SLoc.isMacroID() && !PP.isAtStartOfMacroExpansion(SLoc))
       return true;
   }
   return isSpecializedNodeExcluded(N);
 }
 
-static SourceRange getSourceRange(const ASTUnit &AST, const DynTypedNode &DTN) {
-  const SourceManager &SM = AST.getSourceManager();
-  SourceRange Range = DTN.getSourceRange();
-  SourceLocation BeginLoc = Range.getBegin();
-  SourceLocation EndLoc;
-  if (BeginLoc.isMacroID())
-    EndLoc = SM.getExpansionRange(BeginLoc).second;
-  else
-    EndLoc = Range.getEnd();
-  EndLoc =
-      Lexer::getLocForEndOfToken(EndLoc, /*Offset=*/0, SM, AST.getLangOpts());
-  if (auto *ThisExpr = DTN.get<CXXThisExpr>()) {
-    if (ThisExpr->isImplicit())
-      EndLoc = BeginLoc;
-  }
-  return {SM.getExpansionLoc(BeginLoc), SM.getExpansionLoc(EndLoc)};
-}
-
 namespace {
 // Sets Height, Parent and Children for each node.
 struct PreorderVisitor : public RecursiveASTVisitor<PreorderVisitor> {
   int Id = 0, Depth = 0;
   NodeId Parent;
   SyntaxTree::Impl &Tree;
 
   PreorderVisitor(SyntaxTree::Impl &Tree) : Tree(Tree) {}
if (Init->isDelegatingInitializer())
     return Init->getTypeSourceInfo()->getType().getAsString(TypePP);
   llvm_unreachable("Unknown initializer type");
 }
 
 std::string SyntaxTree::Impl::getNodeValue(NodeRef N) const {
   assert(&N.Tree == this);
   const DynTypedNode &DTN = N.ASTNode;
   if (N.isMacro()) {
-    CharSourceRange Range(getSourceRange(AST, N.ASTNode), false);
-    return Lexer::getSourceText(Range, AST.getSourceManager(),
+    return Lexer::getSourceText(N.getSourceRange(), AST.getSourceManager(),
                                 AST.getLangOpts());
   }
   if (auto *S = DTN.get<Stmt>())
     return getStmtValue(S);
   if (auto *D = DTN.get<Decl>())
     return getDeclValue(D);
   if (auto *Init = DTN.get<CXXCtorInitializer>())
     return getInitializerValue(Init, TypePP);

 int Node::findPositionInParent() const {
   if (!getParent())
     return 0;
   const ArrayRef<NodeId> &Siblings = getParent()->Children;
   return std::find(Siblings.begin(), Siblings.end(), getId()) -
          Siblings.begin();
 }
 
+static SourceRange getSourceRangeImpl(NodeRef N) {
+  const DynTypedNode &DTN = N.ASTNode;
+  SyntaxTree::Impl &Tree = N.Tree;
+  SourceManager &SM = Tree.AST.getSourceManager();
+  const LangOptions &LangOpts = Tree.AST.getLangOpts();
+  auto EndOfToken = [&](SourceLocation Loc) {
+    return Lexer::getLocForEndOfToken(Loc, /*Offset=*/0, SM, LangOpts);
+  };
+  auto TokenToCharRange = [&](SourceRange Range) -> SourceRange {
+    return {Range.getBegin(), EndOfToken(Range.getEnd())};
+  };
+  SourceRange Range = DTN.getSourceRange();
+  if (N.isMacro()) {
+    SourceLocation BeginLoc = Range.getBegin();
+    SourceLocation End = SM.getExpansionRange(BeginLoc).second;
+    End = EndOfToken(End);
+    return {SM.getExpansionLoc(BeginLoc), SM.getExpansionLoc(End)};
+  }
+  if (auto *ThisExpr = DTN.get<CXXThisExpr>())
+    if (ThisExpr->isImplicit())
+      return {Range.getBegin(), Range.getBegin()};
+  if (auto *CE = DTN.get<CXXConstructExpr>()) {
+    if (!isa<CXXTemporaryObjectExpr>(CE))
+      return CE->getParenOrBraceRange();
+  } else if (DTN.get<ParmVarDecl>()) {
+    return TokenToCharRange(Range);
+  } else if (DTN.get<DeclStmt>() || DTN.get<FieldDecl>() ||
+             DTN.get<VarDecl>() ||
+             (DTN.get<CallExpr>() &&
+              N.getParent()->ASTNode.get<CompoundStmt>()) ||
+             (DTN.get<FunctionDecl>() &&
+              !DTN.get<FunctionDecl>()->isThisDeclarationADefinition()) ||
+             DTN.get<TypeDecl>() || DTN.get<UsingDirectiveDecl>() ||
+             DTN.get<ClassTemplateDecl>()) {
+    SourceLocation End = Range.getEnd();
+    if (DTN.get<DeclStmt>())
+      End = End.getLocWithOffset(-1);
+    SourceLocation SemicolonLoc = Lexer::findLocationAfterToken(
+        End, tok::semi, SM, LangOpts,
+        /*SkipTrailingWhitespaceAndNewLine=*/false);
+    Range.setEnd(SemicolonLoc);
+    return Range;
+  }
+  return TokenToCharRange(Range);
+}
+
+CharSourceRange Node::getSourceRange() const {
+  return CharSourceRange::getCharRange(getSourceRangeImpl(*this));
+}
+
 std::pair<unsigned, unsigned> Node::getSourceRangeOffsets() const {
   const SourceManager &SM = Tree.AST.getSourceManager();
-  SourceRange Range = getSourceRange(Tree.AST, ASTNode);
+  CharSourceRange Range = getSourceRange();
   unsigned Begin = SM.getFileOffset(Range.getBegin());
   unsigned End = SM.getFileOffset(Range.getEnd());
   return {Begin, End};
 }
 
 namespace {
 // Compares nodes by their depth.
 struct HeightLess {

test/Tooling/clang-diff-json.cpp

 // RUN: clang-diff -ast-dump-json %s -- \
 // RUN: | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \
 // RUN: | FileCheck %s
 
-// CHECK: "begin": 299,
-// CHECK: "type": "FieldDecl",
-// CHECK: "end": 319,
-// CHECK: "type": "CXXRecordDecl",
+// CHECK: "begin": 297,
+// CHECK: "type": "FieldDecl"
+// CHECK: "end": 318,
+// CHECK: "type": "CXXRecordDecl"
 class A {
   int x;
 };
 
 // CHECK: "children": [
 // CHECK-NEXT: {
 // CHECK-NEXT: "begin":
 // CHECK-NEXT: "children": []