[clang-diff] NFC: renames, moves

lib/Tooling/ASTDiff/ASTDiff.cpp

public:
   NodeRef getRoot() const { return getNode(getRootId()); }
   NodeId getRootId() const { return 0; }
   PreorderIterator begin() const { return &getRoot(); }
   PreorderIterator end() const { return begin() + getSize(); }
 
   NodeRef getNode(NodeId Id) const { return Nodes[Id]; }
   Node &getMutableNode(NodeId Id) { return Nodes[Id]; }
   Node &getMutableNode(NodeRef N) { return getMutableNode(N.getId()); }
-  int getNumberOfDescendants(NodeRef N) const;
-  bool isInSubtree(NodeRef N, NodeRef SubtreeRoot) const;
 
   std::string getRelativeName(const NamedDecl *ND,
                               const DeclContext *Context) const;
   std::string getRelativeName(const NamedDecl *ND) const;
 
   std::string getNodeValue(NodeRef Node) const;
   std::string getDeclValue(const Decl *D) const;
   std::string getStmtValue(const Stmt *S) const;
for (NodeRef Leaf : Leaves) {
     const Node *Parent, *Cur = &Leaf;
     while ((Parent = Cur->getParent()) && &Parent->getChild(0) == Cur) {
       Cur = Parent;
       getMutableNode(*Cur).LeftMostDescendant = Leaf.getId();
     }
   }
 }
 
-int SyntaxTree::Impl::getNumberOfDescendants(NodeRef N) const {
+static int getNumberOfDescendants(NodeRef N) {
   return N.RightMostDescendant - N.getId() + 1;
 }
 
-bool SyntaxTree::Impl::isInSubtree(NodeRef N, NodeRef SubtreeRoot) const {
+static bool isInSubtree(NodeRef N, NodeRef SubtreeRoot) {
   return N.getId() >= SubtreeRoot.getId() &&
          N.getId() <= SubtreeRoot.RightMostDescendant;
 }
 
 // Returns the qualified name of ND. If it is subordinate to Context,
 // then the prefix of the latter is removed from the returned value.
 std::string
 SyntaxTree::Impl::getRelativeName(const NamedDecl *ND,

 
 bool ASTDiff::Impl::haveSameParents(NodeRef N1, NodeRef N2) const {
   const Node *P1 = N1.getParent();
   const Node *P2 = N2.getParent();
   return (!P1 && !P2) || (P1 && P2 && getDst(*P1) == P2);
 }
 
 void ASTDiff::Impl::addOptimalMapping(NodeRef N1, NodeRef N2) {
-  if (std::max(T1.getNumberOfDescendants(N1), T2.getNumberOfDescendants(N2)) >
+  if (std::max(getNumberOfDescendants(N1), getNumberOfDescendants(N2)) >
       Options.MaxSize)
     return;
   ZhangShashaMatcher Matcher(*this, T1, T2, N1.getId(), N2.getId());
   std::vector<std::pair<NodeId, NodeId>> R = Matcher.getMatchingNodes();
   for (const auto Tuple : R) {
     NodeRef N1 = T1.getNode(Tuple.first);
     NodeRef N2 = T2.getNode(Tuple.second);
     if (!getDst(N1) && !getSrc(N2))
       link(N1, N2);
   }
 }
 
 double ASTDiff::Impl::getJaccardSimilarity(NodeRef N1, NodeRef N2) const {
   int CommonDescendants = 0;
   // Count the common descendants, excluding the subtree root.
   for (NodeId Src = N1.getId() + 1; Src <= N1.RightMostDescendant; ++Src) {
     const Node *Dst = getDst(T1.getNode(Src));
     if (Dst)
-      CommonDescendants += T2.isInSubtree(*Dst, N2);
+      CommonDescendants += isInSubtree(*Dst, N2);
   }
   // We need to subtract 1 to get the number of descendants excluding the
   // root.
-  double Denominator = T1.getNumberOfDescendants(N1) - 1 +
-                       T2.getNumberOfDescendants(N2) - 1 - CommonDescendants;
+  double Denominator = getNumberOfDescendants(N1) - 1 +
+                       getNumberOfDescendants(N2) - 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;
 }
 
 const Node *ASTDiff::Impl::findCandidate(NodeRef N1) const {
if (Max2 > Max1) {
         L2.open(N);
       continue;
     }
     NodeList H1 = L1.pop();
     NodeList H2 = L2.pop();
     for (NodeRef N1 : H1) {
       for (NodeRef N2 : H2) {
         if (identical(N1, N2) && !getDst(N1) && !getSrc(N2)) {
-          for (int I = 0, E = T1.getNumberOfDescendants(N1); I < E; ++I) {
+          for (int I = 0, E = getNumberOfDescendants(N1); I < E; ++I) {
             link(T1.getNode(N1.getId() + I), T2.getNode(N2.getId() + I));
           }
         }
       }
     }
     for (NodeRef N1 : H1) {
       if (!getDst(N1))
         L1.open(N1);