TypeGraph: Rename visit(Type) functions to accept(Type)

visit(Type&) and visit(Type*) were helper functions than did cycle
detection and provided nicer syntax for the type.accept(*this) calls.

However, because they overloaded the visit() function, it was easy to
accidentally call a concrete visit method (e.g. visit(Class&)) instead
of the virtual-dispatching visit(Type&).

By changing the name of this wrapper, it will make it much more obvious
when code is introduced which bypasses the cycle detection.

Author: ajor

oi/type_graph/AddChildren.cpp

@@ -36,14 +36,14 @@ Pass AddChildren::createPass(DrgnParser& drgnParser, SymbolService& symbols) {
     AddChildren pass(typeGraph, drgnParser);
     pass.enumerateChildClasses(symbols);
     for (auto& type : typeGraph.rootTypes()) {
-      pass.visit(type);
+      pass.accept(type);
     }
   };
 
   return Pass("AddChildren", fn);
 }
 
-void AddChildren::visit(Type& type) {
+void AddChildren::accept(Type& type) {
   if (visited_.count(&type) != 0)
     return;
 
@@ -53,10 +53,10 @@ void AddChildren::visit(Type& type) {
 
 void AddChildren::visit(Class& c) {
   for (auto& param : c.templateParams) {
-    visit(param.type());
+    accept(param.type());
   }
   for (auto& member : c.members) {
-    visit(member.type());
+    accept(member.type());
   }
 
   if (!c.isDynamic()) {
@@ -82,8 +82,8 @@ void AddChildren::visit(Class& c) {
   }
 
   // Recurse to find children-of-children
-  for (auto& child : c.children) {
-    visit(child);
+  for (const auto& child : c.children) {
+    accept(child);
   }
 }
 

oi/type_graph/AddChildren.h

@@ -46,9 +46,9 @@ class AddChildren final : public RecursiveVisitor {
       : typeGraph_(typeGraph), drgnParser_(drgnParser) {
   }
 
-  using RecursiveVisitor::visit;
+  using RecursiveVisitor::accept;
 
-  void visit(Type& type) override;
+  void accept(Type& type) override;
   void visit(Class& c) override;
 
  private:

oi/type_graph/AddPadding.cpp

@@ -32,14 +32,14 @@ Pass AddPadding::createPass(FeatureSet features) {
   auto fn = [features](TypeGraph& typeGraph) {
     AddPadding pass(typeGraph, features);
     for (auto& type : typeGraph.rootTypes()) {
-      pass.visit(type);
+      pass.accept(type);
     }
   };
 
   return Pass("AddPadding", fn);
 }
 
-void AddPadding::visit(Type& type) {
+void AddPadding::accept(Type& type) {
   if (visited_.count(&type) != 0)
     return;
 
@@ -54,10 +54,10 @@ void AddPadding::visit(Class& c) {
   assert(c.parents.empty());
 
   for (auto& param : c.templateParams) {
-    visit(param.type());
+    accept(param.type());
   }
   for (auto& member : c.members) {
-    visit(member.type());
+    accept(member.type());
   }
 
   if (c.kind() == Class::Kind::Union) {
@@ -94,7 +94,7 @@ void AddPadding::visit(Class& c) {
   c.members = std::move(paddedMembers);
 
   for (const auto& child : c.children) {
-    visit(child);
+    accept(child);
   }
 }
 

oi/type_graph/AddPadding.h

@@ -43,9 +43,9 @@ class AddPadding final : public RecursiveVisitor {
       : typeGraph_(typeGraph), features_(features) {
   }
 
-  using RecursiveVisitor::visit;
+  using RecursiveVisitor::accept;
 
-  void visit(Type& type) override;
+  void accept(Type& type) override;
   void visit(Class& c) override;
 
   static const inline std::string MemberPrefix = "__oi_padding";

oi/type_graph/AlignmentCalc.cpp

@@ -35,11 +35,11 @@ Pass AlignmentCalc::createPass() {
 
 void AlignmentCalc::calculateAlignments(const std::vector<ref<Type>>& types) {
   for (auto& type : types) {
-    visit(type);
+    accept(type);
   }
 };
 
-void AlignmentCalc::visit(Type& type) {
+void AlignmentCalc::accept(Type& type) {
   if (visited_.count(&type) != 0)
     return;
 
@@ -58,7 +58,7 @@ void AlignmentCalc::visit(Class& c) {
     if (member.align == 0) {
       // If the member does not have an explicit alignment, calculate it from
       // the member's type.
-      visit(member.type());
+      accept(member.type());
       member.align = member.type().align();
     }
     alignment = std::max(alignment, member.align);

oi/type_graph/AlignmentCalc.h

@@ -37,9 +37,9 @@ class AlignmentCalc final : public RecursiveVisitor {
   void calculateAlignments(
       const std::vector<std::reference_wrapper<Type>>& types);
 
-  using RecursiveVisitor::visit;
+  using RecursiveVisitor::accept;
 
-  void visit(Type& type) override;
+  void accept(Type& type) override;
   void visit(Class& c) override;
 
  private:

oi/type_graph/Flattener.cpp

@@ -33,11 +33,11 @@ Pass Flattener::createPass() {
 
 void Flattener::flatten(std::vector<std::reference_wrapper<Type>>& types) {
   for (auto& type : types) {
-    visit(type);
+    accept(type);
   }
 }
 
-void Flattener::visit(Type& type) {
+void Flattener::accept(Type& type) {
   if (visited_.count(&type) != 0)
     return;
 
@@ -146,13 +146,13 @@ void Flattener::visit(Class& c) {
 
   // Flatten types referenced by template params, parents and members
   for (const auto& param : c.templateParams) {
-    visit(param.type());
+    accept(param.type());
   }
   for (const auto& parent : c.parents) {
-    visit(parent.type());
+    accept(parent.type());
   }
   for (const auto& member : c.members) {
-    visit(member.type());
+    accept(member.type());
   }
 
   // Pull in functions from flattened parents
@@ -203,15 +203,15 @@ void Flattener::visit(Class& c) {
   // This must be run after flattening the current class in order to respect
   // the changes we have made here.
   for (const auto& child : c.children) {
-    visit(child);
+    accept(child);
   }
 }
 
 void Flattener::visit(Container& c) {
   // Containers themselves don't need to be flattened, but their template
   // parameters might need to be
   for (const auto& templateParam : c.templateParams) {
-    visit(templateParam.type());
+    accept(templateParam.type());
   }
 }
 

oi/type_graph/Flattener.h

@@ -37,9 +37,9 @@ class Flattener : public RecursiveVisitor {
 
   void flatten(std::vector<std::reference_wrapper<Type>>& types);
 
-  using RecursiveVisitor::visit;
+  using RecursiveVisitor::accept;
 
-  void visit(Type& type) override;
+  void accept(Type& type) override;
   void visit(Class& c) override;
   void visit(Container& c) override;
 

oi/type_graph/NameGen.cpp

@@ -33,11 +33,11 @@ Pass NameGen::createPass() {
 
 void NameGen::generateNames(const std::vector<ref<Type>>& types) {
   for (auto& type : types) {
-    visit(type);
+    accept(type);
   }
 };
 
-void NameGen::visit(Type& type) {
+void NameGen::accept(Type& type) {
   if (visited_.count(&type) != 0)
     return;
 
@@ -69,16 +69,16 @@ void NameGen::visit(Class& c) {
   }
 
   for (const auto& param : c.templateParams) {
-    visit(param.type());
+    accept(param.type());
   }
   for (const auto& parent : c.parents) {
-    visit(parent.type());
+    accept(parent.type());
   }
   for (const auto& member : c.members) {
-    visit(member.type());
+    accept(member.type());
   }
   for (const auto& child : c.children) {
-    visit(child);
+    accept(child);
   }
 }
 
@@ -88,7 +88,7 @@ void NameGen::visit(Container& c) {
   }
 
   for (const auto& template_param : c.templateParams) {
-    visit(template_param.type());
+    accept(template_param.type());
   }
 
   std::string name = c.name();
@@ -130,7 +130,7 @@ void NameGen::visit(Typedef& td) {
   // Append an incrementing number to ensure we don't get duplicates
   td.setName(name + "_" + std::to_string(n++));
 
-  visit(td.underlyingType());
+  accept(td.underlyingType());
 }
 
 }  // namespace type_graph

oi/type_graph/NameGen.h

@@ -32,14 +32,14 @@ class NameGen final : public RecursiveVisitor {
 
   void generateNames(const std::vector<std::reference_wrapper<Type>>& types);
 
-  using RecursiveVisitor::visit;
+  using RecursiveVisitor::accept;
 
   void visit(Class& c) override;
   void visit(Container& c) override;
   void visit(Typedef& td) override;
 
  private:
-  void visit(Type& type) override;
+  void accept(Type& type) override;
   void removeTemplateParams(std::string& name);
 
   std::unordered_set<Type*> visited_;