[Dominators] Clean up typedefs in GenericDomTreeConstruction. NFC.

[kuhar]

Summary

This patch cleans up GenericDomTreeConstruction by replacing typedefs with usings and replaces typename GraphT::NodeRef with NodePtr to make the file more readable.

[• dberlin]

include/llvm/Support/GenericDomTree.h

212 ↗

(On Diff #102731)

Please don't mix reformatting changes with other ones, it makes it hard to tell what you did :)

You can use git clang-format or something if you want to format changed lines in a patch :)
https://github.com/llvm-mirror/clang/blob/master/tools/clang-format/git-clang-format

include/llvm/Support/GenericDomTreeConstruction.h

146 ↗

(On Diff #102731)

If nodeptr is now the only place we use GraphT, just fold it into that line and remove it.

[kuhar]

Change in GenericDomTree.h excluded.

[kuhar]

include/llvm/Support/GenericDomTree.h

212 ↗

(On Diff #102731)

Thanks, I missed that

include/llvm/Support/GenericDomTreeConstruction.h

146 ↗

(On Diff #102731)

GraphT is used in a couple of places below.

llvm/trunk/include/llvm/Support/GenericDomTreeConstruction.h

 
 namespace llvm {
 
 // External storage for depth first iterator that reuses the info lookup map
 // domtree already has.  We don't have a set, but a map instead, so we are
 // converting the one argument insert calls.
 template <class NodeRef, class InfoType> struct df_iterator_dom_storage {
 public:
-  typedef DenseMap<NodeRef, InfoType> BaseSet;
+  using BaseSet = DenseMap<NodeRef, InfoType>;
   df_iterator_dom_storage(BaseSet &Storage) : Storage(Storage) {}
 
-  typedef typename BaseSet::iterator iterator;
+  using iterator = typename BaseSet::iterator;
   std::pair<iterator, bool> insert(NodeRef N) {
     return Storage.insert({N, InfoType()});
   }
   void completed(NodeRef) {}
 
 private:
   BaseSet &Storage;
 };
unsigned DFSPass(DominatorTreeBaseByGraphTraits<GraphT> &DT,
   }
   return N;
 }
 
 template <class GraphT>
 typename GraphT::NodeRef Eval(DominatorTreeBaseByGraphTraits<GraphT> &DT,
                               typename GraphT::NodeRef VIn,
                               unsigned LastLinked) {
+  using NodePtr = typename GraphT::NodeRef;
+
   auto &VInInfo = DT.Info[VIn];
   if (VInInfo.DFSNum < LastLinked)
     return VIn;
 
-  SmallVector<typename GraphT::NodeRef, 32> Work;
-  SmallPtrSet<typename GraphT::NodeRef, 32> Visited;
+  SmallVector<NodePtr, 32> Work;
+  SmallPtrSet<NodePtr, 32> Visited;
 
   if (VInInfo.Parent >= LastLinked)
     Work.push_back(VIn);
 
   while (!Work.empty()) {
-    typename GraphT::NodeRef V = Work.back();
+    NodePtr V = Work.back();
     auto &VInfo = DT.Info[V];
-    typename GraphT::NodeRef VAncestor = DT.Vertex[VInfo.Parent];
+    NodePtr VAncestor = DT.Vertex[VInfo.Parent];
 
     // Process Ancestor first
     if (Visited.insert(VAncestor).second && VInfo.Parent >= LastLinked) {
       Work.push_back(VAncestor);
       continue;
     }
     Work.pop_back();
 
     // Update VInfo based on Ancestor info
     if (VInfo.Parent < LastLinked)
       continue;
 
     auto &VAInfo = DT.Info[VAncestor];
-    typename GraphT::NodeRef VAncestorLabel = VAInfo.Label;
-    typename GraphT::NodeRef VLabel = VInfo.Label;
+    NodePtr VAncestorLabel = VAInfo.Label;
+    NodePtr VLabel = VInfo.Label;
     if (DT.Info[VAncestorLabel].Semi < DT.Info[VLabel].Semi)
       VInfo.Label = VAncestorLabel;
     VInfo.Parent = VAInfo.Parent;
   }
 
   return VInInfo.Label;
 }
 
 template <class FuncT, class NodeT>
 void Calculate(DominatorTreeBaseByGraphTraits<GraphTraits<NodeT>> &DT,
                FuncT &F) {
-  typedef GraphTraits<NodeT> GraphT;
-  static_assert(std::is_pointer<typename GraphT::NodeRef>::value,
+  using GraphT = GraphTraits<NodeT>;
+  using NodePtr = typename GraphT::NodeRef;
+  static_assert(std::is_pointer<NodePtr>::value,
                 "NodeRef should be pointer type");
-  typedef typename std::remove_pointer<typename GraphT::NodeRef>::type NodeType;
+  using NodeType = typename std::remove_pointer<NodePtr>::type;
 
   unsigned N = 0;
   bool MultipleRoots = (DT.Roots.size() > 1);
   if (MultipleRoots) {
     auto &BBInfo = DT.Info[nullptr];
     BBInfo.DFSNum = BBInfo.Semi = ++N;
     BBInfo.Label = nullptr;
 
void Calculate(DominatorTreeBaseByGraphTraits<GraphTraits<NodeT>> &DT,
   // bucket is processed, Buckets[i] stores the index of the next element in the
   // bucket containing V, if any.
   SmallVector<unsigned, 32> Buckets;
   Buckets.resize(N + 1);
   for (unsigned i = 1; i <= N; ++i)
     Buckets[i] = i;
 
   for (unsigned i = N; i >= 2; --i) {
-    typename GraphT::NodeRef W = DT.Vertex[i];
+    NodePtr W = DT.Vertex[i];
     auto &WInfo = DT.Info[W];
 
     // Step #2: Implicitly define the immediate dominator of vertices
     for (unsigned j = i; Buckets[j] != i; j = Buckets[j]) {
-      typename GraphT::NodeRef V = DT.Vertex[Buckets[j]];
-      typename GraphT::NodeRef U = Eval<GraphT>(DT, V, i + 1);
+      NodePtr V = DT.Vertex[Buckets[j]];
+      NodePtr U = Eval<GraphT>(DT, V, i + 1);
       DT.IDoms[V] = DT.Info[U].Semi < i ? U : W;
     }
 
     // Step #3: Calculate the semidominators of all vertices
 
     // initialize the semi dominator to point to the parent node
     WInfo.Semi = WInfo.Parent;
     for (const auto &N : inverse_children<NodeT>(W))
if (WInfo.Semi == WInfo.Parent) {
       DT.IDoms[W] = DT.Vertex[WInfo.Parent];
     } else {
       Buckets[i] = Buckets[WInfo.Semi];
       Buckets[WInfo.Semi] = i;
     }
   }
 
   if (N >= 1) {
-    typename GraphT::NodeRef Root = DT.Vertex[1];
+    NodePtr Root = DT.Vertex[1];
     for (unsigned j = 1; Buckets[j] != 1; j = Buckets[j]) {
-      typename GraphT::NodeRef V = DT.Vertex[Buckets[j]];
+      NodePtr V = DT.Vertex[Buckets[j]];
       DT.IDoms[V] = Root;
     }
   }
 
   // Step #4: Explicitly define the immediate dominator of each vertex
   for (unsigned i = 2; i <= N; ++i) {
-    typename GraphT::NodeRef W = DT.Vertex[i];
-    typename GraphT::NodeRef &WIDom = DT.IDoms[W];
+    NodePtr W = DT.Vertex[i];
+    NodePtr &WIDom = DT.IDoms[W];
     if (WIDom != DT.Vertex[DT.Info[W].Semi])
       WIDom = DT.IDoms[WIDom];
   }
 
   if (DT.Roots.empty()) return;
 
   // Add a node for the root.  This node might be the actual root, if there is
   // one exit block, or it may be the virtual exit (denoted by (BasicBlock *)0)
   // which postdominates all real exits if there are multiple exit blocks, or
   // an infinite loop.
-  typename GraphT::NodeRef Root = !MultipleRoots ? DT.Roots[0] : nullptr;
+  NodePtr Root = !MultipleRoots ? DT.Roots[0] : nullptr;
 
   DT.RootNode =
       (DT.DomTreeNodes[Root] =
            llvm::make_unique<DomTreeNodeBase<NodeType>>(Root, nullptr))
           .get();
 
   // Loop over all of the reachable blocks in the function...
   for (unsigned i = 2; i <= N; ++i) {
-    typename GraphT::NodeRef W = DT.Vertex[i];
+    NodePtr W = DT.Vertex[i];
 
     // Don't replace this with 'count', the insertion side effect is important
     if (DT.DomTreeNodes[W])
       continue; // Haven't calculated this node yet?
 
-    typename GraphT::NodeRef ImmDom = DT.getIDom(W);
+    NodePtr ImmDom = DT.getIDom(W);
 
     assert(ImmDom || DT.DomTreeNodes[nullptr]);
 
     // Get or calculate the node for the immediate dominator
     DomTreeNodeBase<NodeType> *IDomNode = DT.getNodeForBlock(ImmDom);
 
     // Add a new tree node for this BasicBlock, and link it as a child of
     // IDomNode