Try reformatting

Author: stevenfontanella

src/passes/GlobalEffects.cpp

@@ -190,16 +190,17 @@ CallGraph buildCallGraph(const Module& module,
   // We are essentially walking up each supertype chain and adding edges from
   // super -> subtype, but doing it via DFS to avoid repeated work.
   Graph superTypeGraph(allFunctionTypes.begin(),
-          allFunctionTypes.end(),
-          [&callGraph](auto&& push, HeapType t) {
-            // Not needed except that during lookup we expect the key to exist.
-            callGraph[t];
-
-            if (auto super = t.getDeclaredSuperType()) {
-              callGraph[*super].insert(t);
-              push(*super);
-            }
-          });
+                       allFunctionTypes.end(),
+                       [&callGraph](auto&& push, HeapType t) {
+                         // Not needed except that during lookup we expect the
+                         // key to exist.
+                         callGraph[t];
+
+                         if (auto super = t.getDeclaredSuperType()) {
+                           callGraph[*super].insert(t);
+                           push(*super);
+                         }
+                       });
   (void)superTypeGraph.traverseDepthFirst();
 
   return callGraph;

src/support/graph_traversal.h

@@ -19,15 +19,19 @@
 namespace wasm {
 
 template<typename T, typename SuccessorFunction>
-  requires std::invocable<SuccessorFunction, std::function<void(const T&)>&, const T&>
-class Graph {
+  requires std::
+    invocable<SuccessorFunction, std::function<void(const T&)>&, const T&>
+  class Graph {
 public:
   template<std::input_iterator It, std::sentinel_for<It> Sen>
     requires std::convertible_to<std::iter_reference_t<It>, T>
   Graph(It rootsBegin, Sen rootsEnd, auto&& successors)
     : roots(rootsBegin, rootsEnd),
       successors(std::forward<decltype(successors)>(successors)) {}
 
+  // Traverse the graph depth-first, calling `successors` exactly once for each
+  // node (unless the node appears multiple times in `roots`). Return the set of
+  // nodes visited.
   std::unordered_set<T> traverseDepthFirst() const {
     std::vector<T> stack(roots.begin(), roots.end());
     std::unordered_set<T> visited(roots.begin(), roots.end());
@@ -62,4 +66,4 @@ template<std::input_iterator It,
 Graph(It, Sen, SuccessorFunction)
   -> Graph<std::iter_value_t<It>, std::decay_t<SuccessorFunction>>;
 
-} // namespace wasm
+} // namespace wasm