[clang-diff] Treat CXXCtorInitializer as a node

[arphaman]

LGTM, with one request below:

lib/Tooling/ASTDiff/ASTDiff.cpp

954

Looks like an unrelated formatting change, please pre-commit it instead.

lib/Tooling/ASTDiff/ASTDiff.cpp

 
 private:
   void initTree();
   void setLeftMostDescendants();
 };
 
 static bool isSpecializedNodeExcluded(const Decl *D) { return D->isImplicit(); }
 static bool isSpecializedNodeExcluded(const Stmt *S) { return false; }
+static bool isSpecializedNodeExcluded(CXXCtorInitializer *I) {
+  return !I->isWritten();
+}
 
 template <class T> static bool isNodeExcluded(ASTUnit &AST, T *N) {
   const SourceManager &SrcMgr = AST.getSourceManager();
   if (!N)
     return true;
-  SourceLocation SLoc = N->getLocStart();
+  SourceLocation SLoc = N->getSourceRange().getBegin();
   if (SLoc.isValid()) {
     // Ignore everything from other files.
     if (!SrcMgr.isInMainFile(SLoc))
       return true;
     const Preprocessor &PP = AST.getPreprocessor();
     if (SLoc.isMacroID() && !PP.isAtStartOfMacroExpansion(SLoc))
       return true;
   }
bool TraverseStmt(Stmt *S) {
     if (isNodeExcluded(Tree.AST, S))
       return true;
     auto SavedState = PreTraverse(S);
     RecursiveASTVisitor<PreorderVisitor>::TraverseStmt(S);
     PostTraverse(SavedState);
     return true;
   }
   bool TraverseType(QualType T) { return true; }
+  bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
+    if (isNodeExcluded(Tree.AST, Init))
+      return true;
+    auto SavedState = PreTraverse(Init);
+    RecursiveASTVisitor<PreorderVisitor>::TraverseConstructorInitializer(Init);
+    PostTraverse(SavedState);
+    return true;
+  }
 };
 } // end anonymous namespace
 
 SyntaxTree::Impl::Impl(SyntaxTree *Parent, ASTUnit &AST)
     : Parent(Parent), AST(AST), TypePP(AST.getLangOpts()) {
   TypePP.AnonymousTagLocations = false;
 }
 
while (S) {
     const auto &P = Parents[0];
     if (const auto *D = P.get<Decl>())
       return D->getDeclContext();
     S = P.get<Stmt>();
   }
   return nullptr;
 }
 
+static std::string getInitializerValue(const CXXCtorInitializer *Init,
+                                       const PrintingPolicy &TypePP) {
+  if (Init->isAnyMemberInitializer())
+    return Init->getAnyMember()->getName();
+  if (Init->isBaseInitializer())
+    return QualType(Init->getBaseClass(), 0).getAsString(TypePP);
+  if (Init->isDelegatingInitializer())
+    return Init->getTypeSourceInfo()->getType().getAsString(TypePP);
+  llvm_unreachable("Unknown initializer type");
+}
+
 std::string SyntaxTree::Impl::getNodeValue(NodeId Id) const {
   return getNodeValue(getNode(Id));
 }
 
 std::string SyntaxTree::Impl::getNodeValue(const Node &N) const {
   const DynTypedNode &DTN = N.ASTNode;
   if (N.isMacro()) {
     CharSourceRange Range(getSourceRange(AST, N.ASTNode), false);
     return Lexer::getSourceText(Range, 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);
   llvm_unreachable("Fatal: unhandled AST node.\n");
 }
 
 std::string SyntaxTree::Impl::getDeclValue(const Decl *D) const {
   std::string Value;
-  if (auto *V = dyn_cast<ValueDecl>(D)) {
-    Value += getRelativeName(V) + "(" + V->getType().getAsString(TypePP) + ")";
-    if (auto *C = dyn_cast<CXXConstructorDecl>(D)) {
-      for (auto *Init : C->inits()) {
-        if (!Init->isWritten())
-          continue;
-        if (Init->isBaseInitializer()) {
-          Value += Init->getBaseClass()->getCanonicalTypeInternal().getAsString(
-              TypePP);
-        } else if (Init->isDelegatingInitializer()) {
-          Value += C->getNameAsString();
-        } else {
-          assert(Init->isAnyMemberInitializer());
-          Value += getRelativeName(Init->getMember());
-        }
-        Value += ",";
-      }
-    }
-    return Value;
-  }
+  if (auto *V = dyn_cast<ValueDecl>(D))
+    return getRelativeName(V) + "(" + V->getType().getAsString(TypePP) + ")";
   if (auto *N = dyn_cast<NamedDecl>(D))
     Value += getRelativeName(N) + ";";
   if (auto *T = dyn_cast<TypedefNameDecl>(D))
     return Value + T->getUnderlyingType().getAsString(TypePP) + ";";
   if (auto *T = dyn_cast<TypeDecl>(D))
     if (T->getTypeForDecl())
       Value +=
           T->getTypeForDecl()->getCanonicalTypeInternal().getAsString(TypePP) +
public:
   DataCollector(const DynTypedNode &DTN, const SyntaxTree::Impl &Tree,
                 llvm::MD5 &DataConsumer)
       : Tree(Tree), Context(Tree.AST.getASTContext()),
         DataConsumer(DataConsumer) {
     if (auto *S = DTN.get<Stmt>())
       ConstStmtVisitor<DataCollector>::Visit(S);
     else if (auto *D = DTN.get<Decl>())
       ConstDeclVisitor<DataCollector>::Visit(D);
+    else if (auto *Init = DTN.get<CXXCtorInitializer>())
+      addData(getInitializerValue(Init, Tree.TypePP));
     else
       llvm_unreachable("Fatal: unhandled AST node.\n");
   }
 
 #define DEF_ADD_DATA(CLASS, CODE)                                              \
   template <class Dummy = void> Dummy Visit##CLASS(const CLASS *D) {           \
     CODE;                                                                      \
     ConstDeclVisitor<DataCollector>::Visit##CLASS(D);                          \
double ASTDiff::Impl::getJaccardSimilarity(const Mapping &M, NodeId Id1,
                                            NodeId Id2) const {
   int CommonDescendants = 0;
   const Node &N1 = T1.getNode(Id1);
   // Count the common descendants, excluding the subtree root.
   for (NodeId Src = Id1 + 1; Src <= N1.RightMostDescendant; ++Src) {
     NodeId Dst = M.getDst(Src);
     CommonDescendants += int(Dst.isValid() && T2.isInSubtree(Dst, Id2));
   }
-  // We need to subtract 1 to get the number of descendants excluding the root.
+  // We need to subtract 1 to get the number of descendants excluding the
+  // root.
   double Denominator = T1.getNumberOfDescendants(Id1) - 1 +
                        T2.getNumberOfDescendants(Id2) - 1 - CommonDescendants;
   // CommonDescendants is less than the size of one subtree.
   assert(Denominator >= 0 && "Expected non-negative denominator.");
   if (Denominator == 0)
     return 0;
   return CommonDescendants / Denominator;
 }

test/Tooling/clang-diff-ast.cpp

if (i == 0)
       return "foo";
     // CHECK-NOT: ImplicitCastExpr
     return 0;
   }
 
   // CHECK: AccessSpecDecl: public(
 public:
   int not_initialized;
-  // All initialized members, bases and delegating initializers are are
-  // appended, separated by commas.
-  // CHECK: CXXConstructorDecl: :X(void (char, int){{( __attribute__\(\(thiscall\)\))?}})Base,:m,(
-  X(char c, int) : Base(), m(0) {
+  // CHECK: CXXConstructorDecl: :X(void (char, int){{( __attribute__\(\(thiscall\)\))?}})(
+  // CHECK-NEXT: ParmVarDecl: s(char)
+  // CHECK-NEXT: ParmVarDecl: (int)
+  // CHECK-NEXT: CXXCtorInitializer: Base
+  // CHECK-NEXT: CXXConstructExpr
+  // CHECK-NEXT: CXXCtorInitializer: m
+  // CHECK-NEXT: IntegerLiteral: 0
+  X(char s, int) : Base(), m(0) {
+    // CHECK-NEXT: CompoundStmt
     // CHECK: MemberExpr: :m(
     int x = m;
   }
-  // CHECK: CXXConstructorDecl: :X(void (char){{( __attribute__\(\(thiscall\)\))?}})X,(
+  // CHECK: CXXConstructorDecl: :X(void (char){{( __attribute__\(\(thiscall\)\))?}})(
+  // CHECK: CXXCtorInitializer: X
   X(char s) : X(s, 4) {}
 };
 
 #define M (void)1
 #define F(a, b) (void)a, b
 void macros() {
   // CHECK: Macro: M(
   M;