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

ajor · ajor · commit 56b5873e773a · 2023-07-07T15:45:29.000+01:00
visit(Type&amp;) 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&amp;)) instead
of the virtual-dispatching visit(Type&amp;).

By changing the name of this wrapper, it will make it much more obvious
when code is introduced which bypasses the cycle detection.
diff --git a/oi/type_graph/AddChildren.cpp b/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);
   }
 }
 
diff --git a/oi/type_graph/AddChildren.h b/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:
diff --git a/oi/type_graph/AddPadding.cpp b/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);
   }
 }
 
diff --git a/oi/type_graph/AddPadding.h b/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";
diff --git a/oi/type_graph/AlignmentCalc.cpp b/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);
diff --git a/oi/type_graph/AlignmentCalc.h b/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:
diff --git a/oi/type_graph/Flattener.cpp b/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());
   }
 }
 
diff --git a/oi/type_graph/Flattener.h b/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;
 
diff --git a/oi/type_graph/NameGen.cpp b/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
diff --git a/oi/type_graph/NameGen.h b/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_;
diff --git a/oi/type_graph/RemoveIgnored.cpp b/oi/type_graph/RemoveIgnored.cpp
@@ -24,14 +24,14 @@ Pass RemoveIgnored::createPass(
   auto fn = [&membersToIgnore](TypeGraph& typeGraph) {
     RemoveIgnored removeIgnored{typeGraph, membersToIgnore};
     for (auto& type : typeGraph.rootTypes()) {
-      removeIgnored.visit(type);
+      removeIgnored.accept(type);
     }
   };
 
   return Pass("RemoveIgnored", fn);
 }
 
-void RemoveIgnored::visit(Type& type) {
+void RemoveIgnored::accept(Type& type) {
   if (visited_.count(&type) != 0)
     return;
 
diff --git a/oi/type_graph/RemoveIgnored.h b/oi/type_graph/RemoveIgnored.h
@@ -42,9 +42,9 @@ class RemoveIgnored : public RecursiveVisitor {
       : typeGraph_(typeGraph), membersToIgnore_(membersToIgnore) {
   }
 
-  using RecursiveVisitor::visit;
+  using RecursiveVisitor::accept;
 
-  void visit(Type& type) override;
+  void accept(Type& type) override;
   void visit(Class& c) override;
 
  private:
diff --git a/oi/type_graph/TopoSorter.cpp b/oi/type_graph/TopoSorter.cpp
@@ -37,7 +37,7 @@ void TopoSorter::sort(const std::vector<ref<Type>>& types) {
     typesToSort_.push(type);
   }
   while (!typesToSort_.empty()) {
-    visit(typesToSort_.front());
+    accept(typesToSort_.front());
     typesToSort_.pop();
   }
 }
@@ -46,7 +46,7 @@ const std::vector<ref<Type>>& TopoSorter::sortedTypes() const {
   return sortedTypes_;
 }
 
-void TopoSorter::visit(Type& type) {
+void TopoSorter::accept(Type& type) {
   if (visited_.count(&type) != 0)
     return;
 
@@ -56,13 +56,13 @@ void TopoSorter::visit(Type& type) {
 
 void TopoSorter::visit(Class& c) {
   for (const auto& parent : c.parents) {
-    visit(parent.type());
+    accept(parent.type());
   }
   for (const auto& mem : c.members) {
-    visit(mem.type());
+    accept(mem.type());
   }
   for (const auto& param : c.templateParams) {
-    visit(param.type());
+    accept(param.type());
   }
   sortedTypes_.push_back(c);
 
@@ -97,7 +97,7 @@ bool containerAllowsIncompleteParams(const Container& c) {
 void TopoSorter::visit(Container& c) {
   if (!containerAllowsIncompleteParams(c)) {
     for (const auto& param : c.templateParams) {
-      visit(param.type());
+      accept(param.type());
     }
   }
   sortedTypes_.push_back(c);
@@ -113,7 +113,7 @@ void TopoSorter::visit(Enum& e) {
 }
 
 void TopoSorter::visit(Typedef& td) {
-  visit(td.underlyingType());
+  accept(td.underlyingType());
   sortedTypes_.push_back(td);
 }
 
diff --git a/oi/type_graph/TopoSorter.h b/oi/type_graph/TopoSorter.h
@@ -38,9 +38,9 @@ class TopoSorter : public RecursiveVisitor {
   void sort(const std::vector<std::reference_wrapper<Type>>& types);
   const std::vector<std::reference_wrapper<Type>>& sortedTypes() const;
 
-  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;
   void visit(Enum& e) override;
diff --git a/oi/type_graph/TypeIdentifier.cpp b/oi/type_graph/TypeIdentifier.cpp
@@ -25,7 +25,7 @@ Pass TypeIdentifier::createPass(
   auto fn = [&passThroughTypes](TypeGraph& typeGraph) {
     TypeIdentifier typeId{typeGraph, passThroughTypes};
     for (auto& type : typeGraph.rootTypes()) {
-      typeId.visit(type);
+      typeId.accept(type);
     }
   };
 
@@ -47,7 +47,7 @@ bool TypeIdentifier::isAllocator(Type& t) {
   return false;
 }
 
-void TypeIdentifier::visit(Type& type) {
+void TypeIdentifier::accept(Type& type) {
   if (visited_.count(&type) != 0)
     return;
 
@@ -111,7 +111,7 @@ void TypeIdentifier::visit(Container& c) {
   }
 
   for (const auto& param : c.templateParams) {
-    visit(param.type());
+    accept(param.type());
   }
 }
 
diff --git a/oi/type_graph/TypeIdentifier.h b/oi/type_graph/TypeIdentifier.h
diff --git a/oi/type_graph/Visitor.h b/oi/type_graph/Visitor.h

Original file line number	Diff line number	Diff line change
`@@ -36,14 +36,14 @@ Pass AddChildren::createPass(DrgnParser& drgnParser, SymbolService& symbols) {`
`36`	`36`	`AddChildren pass(typeGraph, drgnParser);`
`37`	`37`	`pass.enumerateChildClasses(symbols);`
`38`	`38`	`for (auto& type : typeGraph.rootTypes()) {`
`39`		`- pass.visit(type);`
	`39`	`+ pass.accept(type);`
`40`	`40`	`}`
`41`	`41`	`};`
`42`	`42`
`43`	`43`	`return Pass("AddChildren", fn);`
`44`	`44`	`}`
`45`	`45`
`46`		`-void AddChildren::visit(Type& type) {`
	`46`	`+void AddChildren::accept(Type& type) {`
`47`	`47`	`if (visited_.count(&type) != 0)`
`48`	`48`	`return;`
`49`	`49`
`@@ -53,10 +53,10 @@ void AddChildren::visit(Type& type) {`
`53`	`53`
`54`	`54`	`void AddChildren::visit(Class& c) {`
`55`	`55`	`for (auto& param : c.templateParams) {`
`56`		`- visit(param.type());`
	`56`	`+ accept(param.type());`
`57`	`57`	`}`
`58`	`58`	`for (auto& member : c.members) {`
`59`		`- visit(member.type());`
	`59`	`+ accept(member.type());`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`if (!c.isDynamic()) {`
`@@ -82,8 +82,8 @@ void AddChildren::visit(Class& c) {`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`// Recurse to find children-of-children`
`85`		`- for (auto& child : c.children) {`
`86`		`- visit(child);`
	`85`	`+ for (const auto& child : c.children) {`
	`86`	`+ accept(child);`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
Original file line number	Diff line number	Diff line change
`@@ -46,9 +46,9 @@ class AddChildren final : public RecursiveVisitor {`
`46`	`46`	`: typeGraph_(typeGraph), drgnParser_(drgnParser) {`
`47`	`47`	`}`
`48`	`48`
`49`		`- using RecursiveVisitor::visit;`
	`49`	`+ using RecursiveVisitor::accept;`
`50`	`50`
`51`		`- void visit(Type& type) override;`
	`51`	`+ void accept(Type& type) override;`
`52`	`52`	`void visit(Class& c) override;`
`53`	`53`
`54`	`54`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -32,14 +32,14 @@ Pass AddPadding::createPass(FeatureSet features) {`
`32`	`32`	`auto fn = [features](TypeGraph& typeGraph) {`
`33`	`33`	`AddPadding pass(typeGraph, features);`
`34`	`34`	`for (auto& type : typeGraph.rootTypes()) {`
`35`		`- pass.visit(type);`
	`35`	`+ pass.accept(type);`
`36`	`36`	`}`
`37`	`37`	`};`
`38`	`38`
`39`	`39`	`return Pass("AddPadding", fn);`
`40`	`40`	`}`
`41`	`41`
`42`		`-void AddPadding::visit(Type& type) {`
	`42`	`+void AddPadding::accept(Type& type) {`
`43`	`43`	`if (visited_.count(&type) != 0)`
`44`	`44`	`return;`
`45`	`45`
`@@ -54,10 +54,10 @@ void AddPadding::visit(Class& c) {`
`54`	`54`	`assert(c.parents.empty());`
`55`	`55`
`56`	`56`	`for (auto& param : c.templateParams) {`
`57`		`- visit(param.type());`
	`57`	`+ accept(param.type());`
`58`	`58`	`}`
`59`	`59`	`for (auto& member : c.members) {`
`60`		`- visit(member.type());`
	`60`	`+ accept(member.type());`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`if (c.kind() == Class::Kind::Union) {`
`@@ -94,7 +94,7 @@ void AddPadding::visit(Class& c) {`
`94`	`94`	`c.members = std::move(paddedMembers);`
`95`	`95`
`96`	`96`	`for (const auto& child : c.children) {`
`97`		`- visit(child);`
	`97`	`+ accept(child);`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
Original file line number	Diff line number	Diff line change
`@@ -43,9 +43,9 @@ class AddPadding final : public RecursiveVisitor {`
`43`	`43`	`: typeGraph_(typeGraph), features_(features) {`
`44`	`44`	`}`
`45`	`45`
`46`		`- using RecursiveVisitor::visit;`
	`46`	`+ using RecursiveVisitor::accept;`
`47`	`47`
`48`		`- void visit(Type& type) override;`
	`48`	`+ void accept(Type& type) override;`
`49`	`49`	`void visit(Class& c) override;`
`50`	`50`
`51`	`51`	`static const inline std::string MemberPrefix = "__oi_padding";`
Original file line number	Diff line number	Diff line change
`@@ -33,11 +33,11 @@ Pass Flattener::createPass() {`
`33`	`33`
`34`	`34`	`void Flattener::flatten(std::vector<std::reference_wrapper<Type>>& types) {`
`35`	`35`	`for (auto& type : types) {`
`36`		`- visit(type);`
	`36`	`+ accept(type);`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`		`-void Flattener::visit(Type& type) {`
	`40`	`+void Flattener::accept(Type& type) {`
`41`	`41`	`if (visited_.count(&type) != 0)`
`42`	`42`	`return;`
`43`	`43`
`@@ -146,13 +146,13 @@ void Flattener::visit(Class& c) {`
`146`	`146`
`147`	`147`	`// Flatten types referenced by template params, parents and members`
`148`	`148`	`for (const auto& param : c.templateParams) {`
`149`		`- visit(param.type());`
	`149`	`+ accept(param.type());`
`150`	`150`	`}`
`151`	`151`	`for (const auto& parent : c.parents) {`
`152`		`- visit(parent.type());`
	`152`	`+ accept(parent.type());`
`153`	`153`	`}`
`154`	`154`	`for (const auto& member : c.members) {`
`155`		`- visit(member.type());`
	`155`	`+ accept(member.type());`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`// Pull in functions from flattened parents`
`@@ -203,15 +203,15 @@ void Flattener::visit(Class& c) {`
`203`	`203`	`// This must be run after flattening the current class in order to respect`
`204`	`204`	`// the changes we have made here.`
`205`	`205`	`for (const auto& child : c.children) {`
`206`		`- visit(child);`
	`206`	`+ accept(child);`
`207`	`207`	`}`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`void Flattener::visit(Container& c) {`
`211`	`211`	`// Containers themselves don't need to be flattened, but their template`
`212`	`212`	`// parameters might need to be`
`213`	`213`	`for (const auto& templateParam : c.templateParams) {`
`214`		`- visit(templateParam.type());`
	`214`	`+ accept(templateParam.type());`
`215`	`215`	`}`
`216`	`216`	`}`
`217`	`217`
Original file line number	Diff line number	Diff line change
`@@ -33,11 +33,11 @@ Pass NameGen::createPass() {`
`33`	`33`
`34`	`34`	`void NameGen::generateNames(const std::vector<ref<Type>>& types) {`
`35`	`35`	`for (auto& type : types) {`
`36`		`- visit(type);`
	`36`	`+ accept(type);`
`37`	`37`	`}`
`38`	`38`	`};`
`39`	`39`
`40`		`-void NameGen::visit(Type& type) {`
	`40`	`+void NameGen::accept(Type& type) {`
`41`	`41`	`if (visited_.count(&type) != 0)`
`42`	`42`	`return;`
`43`	`43`
`@@ -69,16 +69,16 @@ void NameGen::visit(Class& c) {`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`for (const auto& param : c.templateParams) {`
`72`		`- visit(param.type());`
	`72`	`+ accept(param.type());`
`73`	`73`	`}`
`74`	`74`	`for (const auto& parent : c.parents) {`
`75`		`- visit(parent.type());`
	`75`	`+ accept(parent.type());`
`76`	`76`	`}`
`77`	`77`	`for (const auto& member : c.members) {`
`78`		`- visit(member.type());`
	`78`	`+ accept(member.type());`
`79`	`79`	`}`
`80`	`80`	`for (const auto& child : c.children) {`
`81`		`- visit(child);`
	`81`	`+ accept(child);`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`@@ -88,7 +88,7 @@ void NameGen::visit(Container& c) {`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`for (const auto& template_param : c.templateParams) {`
`91`		`- visit(template_param.type());`
	`91`	`+ accept(template_param.type());`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`std::string name = c.name();`
`@@ -130,7 +130,7 @@ void NameGen::visit(Typedef& td) {`
`130`	`130`	`// Append an incrementing number to ensure we don't get duplicates`
`131`	`131`	`td.setName(name + "_" + std::to_string(n++));`
`132`	`132`
`133`		`- visit(td.underlyingType());`
	`133`	`+ accept(td.underlyingType());`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`} // namespace type_graph`