[flang] Rename "visit" to "Walk" to avoid conflict with std::visit.

The thing called on each parse tree node during the walk is still
referred to as a visitor.

Change "pre" to "Pre" and "post" to "Post" to follow the naming
conventions.

Original-commit: flang-compiler/f18@a6ea1296b150db45495b2bbd06b45432fa009c53
Reviewed-on: https://github.com/flang-compiler/f18/pull/15
Tree-same-pre-rewrite: false

diff --git a/flang/lib/parser/parse-tree-visitor.h b/flang/lib/parser/parse-tree-visitor.h
index 0e09a40..8aac2e0 100644 (file)
--- a/flang/lib/parser/parse-tree-visitor.h
+++ b/flang/lib/parser/parse-tree-visitor.h
@@ -8,12 +8,12 @@
 #include <variant>
 
 /// Parse tree visitor
-/// Call visit(x, visitor) to visit each node under x.
+/// Call Walk(x, visitor) to visit each node under x.
 ///
-/// visitor.pre(x) is called before visiting x and its children are not
+/// visitor.Pre(x) is called before visiting x and its children are not
 /// visited if it returns false.
 ///
-/// visitor.post(x) is called after visiting x.
+/// visitor.Post(x) is called after visiting x.
 
 namespace Fortran {
 namespace parser {
@@ -36,1919 +36,1913 @@ ForEachInTuple(const std::tuple<Ts...> &tuple, Func func) {
 // Helpers: generic visitor that is called if there is no specific one
 // and visitors for std::optional, std::list, and Indirection.
 
-template<typename T, typename V> void visit(const T &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visitor.post(x);
+template<typename T, typename V> void Walk(const T &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    visitor.Post(x);
   }
 }
 
 template<typename T, typename V>
-void visit(const std::optional<T> &x, V &visitor) {
+void Walk(const std::optional<T> &x, V &visitor) {
   if (x) {
-    visit(*x, visitor);
+    Walk(*x, visitor);
   }
 }
 
-template<typename T, typename V> void visit(const std::list<T> &x, V &visitor) {
+template<typename T, typename V> void Walk(const std::list<T> &x, V &visitor) {
   for (const auto &elem : x) {
-    visit(elem, visitor);
+    Walk(elem, visitor);
   }
 }
 
 template<typename T, typename V>
-void visit(const Indirection<T> &x, V &visitor) {
-  visit(*x, visitor);
+void Walk(const Indirection<T> &x, V &visitor) {
+  Walk(*x, visitor);
 }
 
-// Visit the single field 'v' in the class
-template<typename T, typename V>
-void VisitWrapperClass(const T &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.v, visitor);
-    visitor.post(x);
+// Walk the single field 'v' in the class
+template<typename T, typename V> void WalkWrapperClass(const T &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.v, visitor);
+    visitor.Post(x);
   }
 }
 
-// Visit the single tuple field 't' in the class
-template<typename T, typename V> void VisitTupleClass(const T &x, V &visitor) {
-  if (visitor.pre(x)) {
-    ForEachInTuple(x.t, [&](const auto &y) { visit(y, visitor); });
-    visitor.post(x);
+// Walk the single tuple field 't' in the class
+template<typename T, typename V> void WalkTupleClass(const T &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    ForEachInTuple(x.t, [&](const auto &y) { Walk(y, visitor); });
+    visitor.Post(x);
   }
 }
 
-// Visit the single variant field 'u' in the class
-template<typename T, typename V> void VisitUnionClass(const T &x, V &visitor) {
-  if (visitor.pre(x)) {
-    std::visit([&](const auto &y) { visit(y, visitor); }, x.u);
-    visitor.post(x);
+// Walk the single variant field 'u' in the class
+template<typename T, typename V> void WalkUnionClass(const T &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    std::visit([&](const auto &y) { Walk(y, visitor); }, x.u);
+    visitor.Post(x);
   }
 }
 
 }  // namespace
 
-template<typename T, typename V> void visit(const Scalar<T> &x, V &visitor) {
-  visit(x.thing, visitor);
+template<typename T, typename V> void Walk(const Scalar<T> &x, V &visitor) {
+  Walk(x.thing, visitor);
 }
 
-template<typename T, typename V> void visit(const Constant<T> &x, V &visitor) {
-  visit(x.thing, visitor);
+template<typename T, typename V> void Walk(const Constant<T> &x, V &visitor) {
+  Walk(x.thing, visitor);
 }
 
-template<typename T, typename V> void visit(const Integer<T> &x, V &visitor) {
-  visit(x.thing, visitor);
+template<typename T, typename V> void Walk(const Integer<T> &x, V &visitor) {
+  Walk(x.thing, visitor);
 }
 
-template<typename T, typename V> void visit(const Logical<T> &x, V &visitor) {
-  visit(x.thing, visitor);
+template<typename T, typename V> void Walk(const Logical<T> &x, V &visitor) {
+  Walk(x.thing, visitor);
 }
 
 template<typename T, typename V>
-void visit(const DefaultChar<T> &x, V &visitor) {
-  visit(x.thing, visitor);
+void Walk(const DefaultChar<T> &x, V &visitor) {
+  Walk(x.thing, visitor);
 }
 
-template<typename T, typename V> void visit(const Statement<T> &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.statement, visitor);
-    visitor.post(x);
+template<typename T, typename V> void Walk(const Statement<T> &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.statement, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename T, typename V>
-void visit(const LoopBounds<T> &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.name, visitor);
-    visit(x.lower, visitor);
-    visit(x.upper, visitor);
-    visit(x.step, visitor);
-    visitor.post(x);
+template<typename T, typename V> void Walk(const LoopBounds<T> &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.name, visitor);
+    Walk(x.lower, visitor);
+    Walk(x.upper, visitor);
+    Walk(x.step, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const AcImpliedDo &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AcImpliedDo &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AcImpliedDoControl &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AcImpliedDoControl &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AcSpec &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.type, visitor);
-    visit(x.values, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const AcSpec &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.type, visitor);
+    Walk(x.values, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const AcValue &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const AcValue &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const AcValue::Triplet &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AcValue::Triplet &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AccessId &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const AccessId &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const AccessStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AccessStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ActionStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ActionStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ActualArg &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ActualArg &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ActualArg::PercentRef &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ActualArg::PercentRef &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ActualArg::PercentVal &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ActualArg::PercentVal &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ActualArgSpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ActualArgSpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AllocOpt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const AllocOpt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const AllocOpt::Mold &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const AllocOpt::Mold &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const AllocOpt::Source &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const AllocOpt::Source &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const AllocatableStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const AllocatableStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const AllocateCoarraySpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AllocateCoarraySpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AllocateObject &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const AllocateObject &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const AllocateShapeSpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AllocateShapeSpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AllocateStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AllocateStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Allocation &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Allocation &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AltReturnSpec &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const AltReturnSpec &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ArithmeticIfStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ArithmeticIfStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ArrayConstructor &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ArrayConstructor &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ArrayElement &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.base, visitor);
-    visit(x.subscripts, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const ArrayElement &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.base, visitor);
+    Walk(x.subscripts, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const ArraySpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ArraySpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const AssignStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AssignStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AssignedGotoStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AssignedGotoStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AssignmentStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AssignmentStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AssociateConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AssociateConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AssociateStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AssociateStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Association &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Association &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AssumedImpliedSpec &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const AssumedImpliedSpec &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const AssumedShapeSpec &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const AssumedShapeSpec &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const AssumedSizeSpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const AssumedSizeSpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const AsynchronousStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const AsynchronousStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const AttrSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const AttrSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const BOZLiteralConstant &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const BOZLiteralConstant &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const BackspaceStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const BackspaceStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const BasedPointerStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const BasedPointerStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const BindAttr &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const BindAttr &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const BindEntity &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const BindEntity &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const BindStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const BindStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const BlockConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const BlockConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const BlockData &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const BlockData &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const BlockDataStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const BlockDataStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const BlockSpecificationPart &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const BlockSpecificationPart &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const BlockStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const BlockStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const BoundsRemapping &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const BoundsRemapping &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const BoundsSpec &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const BoundsSpec &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const Call &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Call &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CallStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const CallStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const CaseConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const CaseConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CaseConstruct::Case &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const CaseConstruct::Case &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CaseSelector &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const CaseSelector &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const CaseStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const CaseStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CaseValueRange &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const CaseValueRange &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ChangeTeamConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ChangeTeamConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ChangeTeamStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ChangeTeamStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CharLength &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const CharLength &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const CharLiteralConstant &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const CharLiteralConstant &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
 template<typename V>
-void visit(const CharLiteralConstantSubstring &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+void Walk(const CharLiteralConstantSubstring &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CharSelector &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const CharSelector &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
 template<typename V>
-void visit(const CharSelector::LengthAndKind &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.length, visitor);
-    visit(x.kind, visitor);
-    visitor.post(x);
+void Walk(const CharSelector::LengthAndKind &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.length, visitor);
+    Walk(x.kind, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const CharVariable &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const CharVariable &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const CloseStmt::CloseSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const CloseStmt::CloseSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const CoarrayAssociation &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const CoarrayAssociation &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CoarraySpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const CoarraySpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const CodimensionDecl &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const CodimensionDecl &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CodimensionStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const CodimensionStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const CoindexedNamedObject &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.base, visitor);
-    visit(x.imageSelector, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const CoindexedNamedObject &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.base, visitor);
+    Walk(x.imageSelector, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const CommonBlockObject &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const CommonBlockObject &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CommonStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const CommonStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ComplexLiteralConstant &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ComplexLiteralConstant &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ComplexPart &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ComplexPart &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ComponentArraySpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ComponentArraySpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ComponentAttrSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ComponentAttrSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ComponentDataSource &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ComponentDataSource &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ComponentDecl &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ComponentDecl &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ComponentDefStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ComponentDefStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ComponentSpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ComponentSpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ComputedGotoStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ComputedGotoStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ConcurrentControl &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ConcurrentControl &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ConcurrentHeader &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ConcurrentHeader &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ConnectSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ConnectSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ConnectSpec::CharExpr &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ConnectSpec::CharExpr &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ConnectSpec::Newunit &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ConnectSpec::Newunit &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ConnectSpec::Recl &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ConnectSpec::Recl &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ConstantValue &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ConstantValue &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ContiguousStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ContiguousStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const CriticalConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const CriticalConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CriticalStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const CriticalStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const CycleStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const CycleStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const DataComponentDefStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const DataComponentDefStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const DataIDoObject &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const DataIDoObject &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const DataImpliedDo &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const DataImpliedDo &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const DataReference &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const DataReference &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const DataStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const DataStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const DataStmtConstant &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const DataStmtConstant &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const DataStmtObject &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const DataStmtObject &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const DataStmtRepeat &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const DataStmtRepeat &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const DataStmtSet &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const DataStmtSet &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const DataStmtValue &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const DataStmtValue &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const DeallocateStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const DeallocateStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const DeclarationConstruct &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const DeclarationConstruct &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const DeclarationTypeSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const DeclarationTypeSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
 template<typename V>
-void visit(const DeclarationTypeSpec::Class &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.derived, visitor);
-    visitor.post(x);
+void Walk(const DeclarationTypeSpec::Class &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.derived, visitor);
+    visitor.Post(x);
   }
 }
 
 template<typename V>
-void visit(const DeclarationTypeSpec::Record &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+void Walk(const DeclarationTypeSpec::Record &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V>
-void visit(const DeclarationTypeSpec::Type &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.derived, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const DeclarationTypeSpec::Type &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.derived, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const DeferredCoshapeSpecList &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const DeferredCoshapeSpecList &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const DeferredShapeSpecList &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const DeferredShapeSpecList &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const DefinedOpName &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const DefinedOpName &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const DefinedOperator &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const DefinedOperator &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const DerivedTypeDef &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const DerivedTypeDef &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const DerivedTypeSpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const DerivedTypeSpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const DerivedTypeStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const DerivedTypeStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Designator &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const Designator &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
 template<typename V>
-void visit(const DimensionStmt::Declaration &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+void Walk(const DimensionStmt::Declaration &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const DoConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const DoConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const DummyArg &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const DummyArg &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ElseIfStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ElseIfStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ElseStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ElseStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ElsewhereStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ElsewhereStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndAssociateStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndAssociateStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndBlockDataStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndBlockDataStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndBlockStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndBlockStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndChangeTeamStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const EndChangeTeamStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const EndCriticalStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndCriticalStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndDoStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndDoStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndForallStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndForallStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndFunctionStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndFunctionStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndIfStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndIfStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndInterfaceStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndInterfaceStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndLabel &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndLabel &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndModuleStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndModuleStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndMpSubprogramStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndMpSubprogramStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndProgramStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndProgramStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndSelectStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndSelectStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndSubmoduleStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndSubmoduleStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndSubroutineStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndSubroutineStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndTypeStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndTypeStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndWhereStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EndWhereStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EndfileStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const EndfileStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const EntityDecl &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const EntityDecl &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const EntryStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const EntryStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const EnumDef &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const EnumDef &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Enumerator &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Enumerator &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const EnumeratorDefStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EnumeratorDefStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EorLabel &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EorLabel &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EquivalenceObject &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EquivalenceObject &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EquivalenceStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const EquivalenceStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ErrLabel &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ErrLabel &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const EventPostStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const EventPostStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const EventWaitStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const EventWaitStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
 template<typename V>
-void visit(const EventWaitStmt::EventWaitSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+void Walk(const EventWaitStmt::EventWaitSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ExecutableConstruct &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ExecutableConstruct &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ExecutionPartConstruct &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ExecutionPartConstruct &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ExitStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ExitStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ExplicitCoshapeSpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ExplicitCoshapeSpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ExplicitShapeSpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ExplicitShapeSpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ExponentPart &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ExponentPart &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Expr &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const Expr &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const Expr::AND &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::AND &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::Add &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::Add &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::ComplexConstructor &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::ComplexConstructor &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::Concat &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::Concat &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::DefinedBinary &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Expr::DefinedBinary &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Expr::DefinedUnary &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Expr::DefinedUnary &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Expr::Divide &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::Divide &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::EQ &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::EQ &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::EQV &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::EQV &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::GE &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::GE &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::GT &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::GT &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::IntrinsicBinary &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Expr::IntrinsicBinary &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Expr::IntrinsicUnary &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const Expr::IntrinsicUnary &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const Expr::LE &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::LE &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::LT &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::LT &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::Multiply &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::Multiply &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::NE &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::NE &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::NEQV &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::NEQV &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::NOT &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicUnary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::NOT &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicUnary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::Negate &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicUnary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::Negate &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicUnary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::OR &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::OR &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::Parentheses &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicUnary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::Parentheses &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicUnary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::PercentLoc &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const Expr::PercentLoc &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const Expr::Power &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::Power &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::Subtract &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::Subtract &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicBinary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Expr::UnaryPlus &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(static_cast<const Expr::IntrinsicUnary &>(x), visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Expr::UnaryPlus &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(static_cast<const Expr::IntrinsicUnary &>(x), visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const ExternalStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ExternalStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const FileUnitNumber &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const FileUnitNumber &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const FinalProcedureStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const FinalProcedureStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const FlushStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const FlushStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ForallAssignmentStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ForallAssignmentStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ForallBodyConstruct &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ForallBodyConstruct &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ForallConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ForallConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ForallConstructStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ForallConstructStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ForallStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ForallStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const FormTeamStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const FormTeamStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
 template<typename V>
-void visit(const FormTeamStmt::FormTeamSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+void Walk(const FormTeamStmt::FormTeamSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const Format &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const Format &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const FormatStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const FormatStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const Fortran::ControlEditDesc &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.kind, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Fortran::ControlEditDesc &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.kind, visitor);
+    visitor.Post(x);
   }
 }
 
 template<typename V>
-void visit(const Fortran::DerivedTypeDataEditDesc &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.type, visitor);
-    visit(x.parameters, visitor);
-    visitor.post(x);
+void Walk(const Fortran::DerivedTypeDataEditDesc &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.type, visitor);
+    Walk(x.parameters, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Fortran::FormatItem &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const Fortran::FormatItem &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
 template<typename V>
-void visit(const Fortran::IntrinsicTypeDataEditDesc &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.kind, visitor);
-    visit(x.width, visitor);
-    visit(x.digits, visitor);
-    visit(x.exponentWidth, visitor);
-    visitor.post(x);
+void Walk(const Fortran::IntrinsicTypeDataEditDesc &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.kind, visitor);
+    Walk(x.width, visitor);
+    Walk(x.digits, visitor);
+    Walk(x.exponentWidth, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const FunctionReference &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const FunctionReference &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const FunctionStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const FunctionStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const FunctionSubprogram &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const FunctionSubprogram &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const GenericSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const GenericSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const GenericStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const GenericStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const GotoStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const GotoStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const IdExpr &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const IdExpr &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const IdVariable &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const IdVariable &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const IfConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const IfConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const IfConstruct::ElseBlock &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const IfConstruct::ElseBlock &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const IfConstruct::ElseIfBlock &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const IfConstruct::ElseIfBlock &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const IfStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const IfStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const IfThenStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const IfThenStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ImageSelector &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ImageSelector &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ImageSelectorSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ImageSelectorSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ImageSelectorSpec::Stat &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ImageSelectorSpec::Stat &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ImageSelectorSpec::Team &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ImageSelectorSpec::Team &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
 template<typename V>
-void visit(const ImageSelectorSpec::Team_Number &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+void Walk(const ImageSelectorSpec::Team_Number &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ImplicitPart &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ImplicitPart &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ImplicitPartStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ImplicitPartStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ImplicitSpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ImplicitSpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ImplicitStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ImplicitStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ImpliedShapeSpec &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ImpliedShapeSpec &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ImportStmt &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.names, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const ImportStmt &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.names, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Initialization &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const Initialization &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const InputImpliedDo &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const InputImpliedDo &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const InputItem &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const InputItem &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const InquireSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const InquireSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const InquireSpec::CharVar &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const InquireSpec::CharVar &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const InquireSpec::IntVar &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const InquireSpec::IntVar &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const InquireSpec::LogVar &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const InquireSpec::LogVar &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const InquireStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const InquireStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const InquireStmt::Iolength &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const InquireStmt::Iolength &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const IntLiteralConstant &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const IntLiteralConstant &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const IntegerTypeSpec &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const IntegerTypeSpec &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const IntentStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const IntentStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const InterfaceBlock &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const InterfaceBlock &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const InterfaceBody &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const InterfaceBody &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const InterfaceBody::Function &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const InterfaceBody::Function &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V>
-void visit(const InterfaceBody::Subroutine &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const InterfaceBody::Subroutine &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const InterfaceSpecification &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const InterfaceSpecification &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const InterfaceStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const InterfaceStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const InternalSubprogram &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const InternalSubprogram &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const InternalSubprogramPart &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const InternalSubprogramPart &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const IntrinsicStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const IntrinsicStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const IntrinsicTypeSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const IntrinsicTypeSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
 template<typename V>
-void visit(const IntrinsicTypeSpec::Character &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.selector, visitor);
-    visitor.post(x);
+void Walk(const IntrinsicTypeSpec::Character &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.selector, visitor);
+    visitor.Post(x);
   }
 }
 
 template<typename V>
-void visit(const IntrinsicTypeSpec::Complex &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.kind, visitor);
-    visitor.post(x);
+void Walk(const IntrinsicTypeSpec::Complex &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.kind, visitor);
+    visitor.Post(x);
   }
 }
 
 template<typename V>
-void visit(const IntrinsicTypeSpec::Logical &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.kind, visitor);
-    visitor.post(x);
+void Walk(const IntrinsicTypeSpec::Logical &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.kind, visitor);
+    visitor.Post(x);
   }
 }
 
 template<typename V>
-void visit(const IntrinsicTypeSpec::NCharacter &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+void Walk(const IntrinsicTypeSpec::NCharacter &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const IntrinsicTypeSpec::Real &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.kind, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const IntrinsicTypeSpec::Real &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.kind, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const IoControlSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const IoControlSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
 template<typename V>
-void visit(const IoControlSpec::Asynchronous &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+void Walk(const IoControlSpec::Asynchronous &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const IoControlSpec::CharExpr &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const IoControlSpec::CharExpr &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const IoControlSpec::Pos &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const IoControlSpec::Pos &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const IoControlSpec::Rec &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const IoControlSpec::Rec &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const IoControlSpec::Size &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const IoControlSpec::Size &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const IoUnit &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const IoUnit &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const KindParam &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const KindParam &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const LabelDoStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const LabelDoStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const LanguageBindingSpec &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const LanguageBindingSpec &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const LengthSelector &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const LengthSelector &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const LetterSpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const LetterSpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const LiteralConstant &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const LiteralConstant &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const LocalitySpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const LocalitySpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const LocalitySpec::Local &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const LocalitySpec::Local &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const LocalitySpec::LocalInit &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const LocalitySpec::LocalInit &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const LocalitySpec::Shared &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const LocalitySpec::Shared &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const LockStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const LockStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const LockStmt::LockStat &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const LockStmt::LockStat &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const LogicalLiteralConstant &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const LogicalLiteralConstant &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const LoopControl &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const LoopControl &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const LoopControl::Concurrent &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const LoopControl::Concurrent &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const MainProgram &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const MainProgram &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Map &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Map &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const MaskedElsewhereStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const MaskedElsewhereStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Module &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Module &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ModuleStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ModuleStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ModuleSubprogram &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ModuleSubprogram &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ModuleSubprogramPart &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ModuleSubprogramPart &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const MpSubprogramStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const MpSubprogramStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const MsgVariable &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const MsgVariable &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const NamedConstant &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const NamedConstant &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const NamedConstantDef &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const NamedConstantDef &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const NamelistStmt::Group &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const NamelistStmt::Group &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const NonLabelDoStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const NonLabelDoStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const NullifyStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const NullifyStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ObjectDecl &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ObjectDecl &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Only &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const Only &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const OpenStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const OpenStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const OptionalStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const OptionalStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const OtherSpecificationStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const OtherSpecificationStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const OutputImpliedDo &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const OutputImpliedDo &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const OutputItem &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const OutputItem &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ParameterStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ParameterStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ParentIdentifier &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ParentIdentifier &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const PartRef &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.name, visitor);
-    visit(x.subscripts, visitor);
-    visit(x.imageSelector, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const PartRef &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.name, visitor);
+    Walk(x.subscripts, visitor);
+    Walk(x.imageSelector, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const Pass &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const Pass &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const PauseStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const PauseStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const PointerAssignmentStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const PointerAssignmentStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
 template<typename V>
-void visit(const PointerAssignmentStmt::Bounds &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+void Walk(const PointerAssignmentStmt::Bounds &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const PointerDecl &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const PointerDecl &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const PointerObject &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const PointerObject &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const PointerStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const PointerStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const PositionOrFlushSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const PositionOrFlushSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const PrefixSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const PrefixSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const PrintStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const PrintStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const PrivateOrSequence &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const PrivateOrSequence &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ProcAttrSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ProcAttrSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ProcComponentAttrSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ProcComponentAttrSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ProcComponentDefStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ProcComponentDefStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ProcComponentRef &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ProcComponentRef &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ProcDecl &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ProcDecl &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ProcInterface &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ProcInterface &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ProcPointerInit &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ProcPointerInit &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ProcedureDeclarationStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ProcedureDeclarationStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ProcedureDesignator &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ProcedureDesignator &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ProcedureStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const ProcedureStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Program &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const Program &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ProgramUnit &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const ProgramUnit &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ProtectedStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ProtectedStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const ReadStmt &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.iounit, visitor);
-    visit(x.format, visitor);
-    visit(x.controls, visitor);
-    visit(x.items, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const ReadStmt &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.iounit, visitor);
+    Walk(x.format, visitor);
+    Walk(x.controls, visitor);
+    Walk(x.items, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const RealLiteralConstant &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.intPart, visitor);
-    visit(x.fraction, visitor);
-    visit(x.exponent, visitor);
-    visit(x.kind, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const RealLiteralConstant &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.intPart, visitor);
+    Walk(x.fraction, visitor);
+    Walk(x.exponent, visitor);
+    Walk(x.kind, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const RedimensionStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const RedimensionStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Rename &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const Rename &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const Rename::Names &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Rename::Names &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Rename::Operators &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Rename::Operators &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const ReturnStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ReturnStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const RewindStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const RewindStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const SaveStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const SaveStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const SavedEntity &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SavedEntity &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SectionSubscript &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const SectionSubscript &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const SelectCaseStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SelectCaseStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SelectRankCaseStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SelectRankCaseStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SelectRankCaseStmt::Rank &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const SelectRankCaseStmt::Rank &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const SelectRankConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SelectRankConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
 template<typename V>
-void visit(const SelectRankConstruct::RankCase &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+void Walk(const SelectRankConstruct::RankCase &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SelectRankStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SelectRankStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SelectTypeConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SelectTypeConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
 template<typename V>
-void visit(const SelectTypeConstruct::TypeCase &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+void Walk(const SelectTypeConstruct::TypeCase &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SelectTypeStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SelectTypeStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Selector &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const Selector &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const SeparateModuleSubprogram &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SeparateModuleSubprogram &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
 template<typename V>
-void visit(const SignedComplexLiteralConstant &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+void Walk(const SignedComplexLiteralConstant &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SignedIntLiteralConstant &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SignedIntLiteralConstant &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V>
-void visit(const SignedRealLiteralConstant &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SignedRealLiteralConstant &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SpecificationConstruct &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const SpecificationConstruct &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const SpecificationExpr &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const SpecificationExpr &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const SpecificationPart &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SpecificationPart &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const StatOrErrmsg &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const StatOrErrmsg &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const StatVariable &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const StatVariable &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const StatusExpr &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const StatusExpr &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const StmtFunctionStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const StmtFunctionStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const StopCode &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const StopCode &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const StopStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const StopStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const StructureComponent &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.base, visitor);
-    visit(x.component, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const StructureComponent &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.base, visitor);
+    Walk(x.component, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const StructureConstructor &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const StructureConstructor &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const StructureDef &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const StructureDef &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const StructureField &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const StructureField &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const StructureStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const StructureStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Submodule &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Submodule &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SubmoduleStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SubmoduleStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SubroutineStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SubroutineStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SubroutineSubprogram &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SubroutineSubprogram &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SubscriptTriplet &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SubscriptTriplet &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Substring &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Substring &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SubstringRange &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SubstringRange &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const Suffix &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.binding, visitor);
-    visit(x.resultName, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const Suffix &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.binding, visitor);
+    Walk(x.resultName, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const SyncAllStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const SyncAllStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const SyncImagesStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SyncImagesStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const SyncImagesStmt::ImageSet &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const SyncImagesStmt::ImageSet &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const SyncMemoryStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const SyncMemoryStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const SyncTeamStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const SyncTeamStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const TargetStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const TargetStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeAttrSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const TypeAttrSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeAttrSpec::Extends &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.name, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const TypeAttrSpec::Extends &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.name, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const TypeBoundGenericStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const TypeBoundGenericStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeBoundProcBinding &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const TypeBoundProcBinding &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeBoundProcDecl &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const TypeBoundProcDecl &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeBoundProcedurePart &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const TypeBoundProcedurePart &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeBoundProcedureStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const TypeBoundProcedureStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
 template<typename V>
-void visit(const TypeBoundProcedureStmt::WithInterface &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.interfaceName, visitor);
-    visit(x.attributes, visitor);
-    visit(x.bindingNames, visitor);
-    visitor.post(x);
+void Walk(const TypeBoundProcedureStmt::WithInterface &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.interfaceName, visitor);
+    Walk(x.attributes, visitor);
+    Walk(x.bindingNames, visitor);
+    visitor.Post(x);
   }
 }
 
 template<typename V>
-void visit(const TypeBoundProcedureStmt::WithoutInterface &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.attributes, visitor);
-    visit(x.declarations, visitor);
-    visitor.post(x);
+void Walk(const TypeBoundProcedureStmt::WithoutInterface &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.attributes, visitor);
+    Walk(x.declarations, visitor);
+    visitor.Post(x);
   }
 }
 
-template<typename V> void visit(const TypeDeclarationStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const TypeDeclarationStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeGuardStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const TypeGuardStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeGuardStmt::Guard &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const TypeGuardStmt::Guard &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeParamDecl &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const TypeParamDecl &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeParamDefStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const TypeParamDefStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeParamSpec &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const TypeParamSpec &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeParamValue &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const TypeParamValue &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const TypeSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const TypeSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const Union &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const Union &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const UnlockStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const UnlockStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const UseStmt &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const UseStmt &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const ValueStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const ValueStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const Variable &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const Variable &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const VolatileStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const VolatileStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const WaitSpec &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const WaitSpec &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const WaitStmt &x, V &visitor) {
-  VisitWrapperClass(x, visitor);
+template<typename V> void Walk(const WaitStmt &x, V &visitor) {
+  WalkWrapperClass(x, visitor);
 }
 
-template<typename V> void visit(const WhereBodyConstruct &x, V &visitor) {
-  VisitUnionClass(x, visitor);
+template<typename V> void Walk(const WhereBodyConstruct &x, V &visitor) {
+  WalkUnionClass(x, visitor);
 }
 
-template<typename V> void visit(const WhereConstruct &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const WhereConstruct &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V>
-void visit(const WhereConstruct::Elsewhere &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const WhereConstruct::Elsewhere &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
 template<typename V>
-void visit(const WhereConstruct::MaskedElsewhere &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+void Walk(const WhereConstruct::MaskedElsewhere &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const WhereConstructStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const WhereConstructStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const WhereStmt &x, V &visitor) {
-  VisitTupleClass(x, visitor);
+template<typename V> void Walk(const WhereStmt &x, V &visitor) {
+  WalkTupleClass(x, visitor);
 }
 
-template<typename V> void visit(const WriteStmt &x, V &visitor) {
-  if (visitor.pre(x)) {
-    visit(x.iounit, visitor);
-    visit(x.format, visitor);
-    visit(x.controls, visitor);
-    visit(x.items, visitor);
-    visitor.post(x);
+template<typename V> void Walk(const WriteStmt &x, V &visitor) {
+  if (visitor.Pre(x)) {
+    Walk(x.iounit, visitor);
+    Walk(x.format, visitor);
+    Walk(x.controls, visitor);
+    Walk(x.items, visitor);
+    visitor.Post(x);
   }
 }
 

diff --git a/flang/tools/f18/test-visitor.cc b/flang/tools/f18/test-visitor.cc
index a0179a7..7bf71d4 100644 (file)
--- a/flang/tools/f18/test-visitor.cc
+++ b/flang/tools/f18/test-visitor.cc
@@ -39,1954 +39,1954 @@ class Visitor {
 
 public:
 
-  bool pre(const Abstract &x) {
+  bool Pre(const Abstract &x) {
     out("Abstract");
     return true;
   }
-  bool pre(const AcImpliedDo &x) {
+  bool Pre(const AcImpliedDo &x) {
     out("AcImpliedDo");
     return true;
   }
-  bool pre(const AcImpliedDoControl &x) {
+  bool Pre(const AcImpliedDoControl &x) {
     out("AcImpliedDoControl");
     return true;
   }
-  bool pre(const AcSpec &x) {
+  bool Pre(const AcSpec &x) {
     out("AcSpec");
     return true;
   }
-  bool pre(const AcValue &x) {
+  bool Pre(const AcValue &x) {
     out("AcValue");
     return true;
   }
-  bool pre(const AcValue::Triplet &x) {
+  bool Pre(const AcValue::Triplet &x) {
     out("AcValue::Triplet");
     return true;
   }
-  bool pre(const AccessId &x) {
+  bool Pre(const AccessId &x) {
     out("AccessId");
     return true;
   }
-  bool pre(const AccessSpec &x) {
+  bool Pre(const AccessSpec &x) {
     out("AccessSpec");
     return true;
   }
-  bool pre(const AccessStmt &x) {
+  bool Pre(const AccessStmt &x) {
     out("AccessStmt");
     return true;
   }
-  bool pre(const ActionStmt &x) {
+  bool Pre(const ActionStmt &x) {
     out("ActionStmt");
     return true;
   }
-  bool pre(const ActualArg &x) {
+  bool Pre(const ActualArg &x) {
     out("ActualArg");
     return true;
   }
-  bool pre(const ActualArg::PercentRef &x) {
+  bool Pre(const ActualArg::PercentRef &x) {
     out("ActualArg::PercentRef");
     return true;
   }
-  bool pre(const ActualArg::PercentVal &x) {
+  bool Pre(const ActualArg::PercentVal &x) {
     out("ActualArg::PercentVal");
     return true;
   }
-  bool pre(const ActualArgSpec &x) {
+  bool Pre(const ActualArgSpec &x) {
     out("ActualArgSpec");
     return true;
   }
-  bool pre(const AllocOpt &x) {
+  bool Pre(const AllocOpt &x) {
     out("AllocOpt");
     return true;
   }
-  bool pre(const AllocOpt::Mold &x) {
+  bool Pre(const AllocOpt::Mold &x) {
     out("AllocOpt::Mold");
     return true;
   }
-  bool pre(const AllocOpt::Source &x) {
+  bool Pre(const AllocOpt::Source &x) {
     out("AllocOpt::Source");
     return true;
   }
-  bool pre(const Allocatable &x) {
+  bool Pre(const Allocatable &x) {
     out("Allocatable");
     return true;
   }
-  bool pre(const AllocatableStmt &x) {
+  bool Pre(const AllocatableStmt &x) {
     out("AllocatableStmt");
     return true;
   }
-  bool pre(const AllocateCoarraySpec &x) {
+  bool Pre(const AllocateCoarraySpec &x) {
     out("AllocateCoarraySpec");
     return true;
   }
-  bool pre(const AllocateObject &x) {
+  bool Pre(const AllocateObject &x) {
     out("AllocateObject");
     return true;
   }
-  bool pre(const AllocateShapeSpec &x) {
+  bool Pre(const AllocateShapeSpec &x) {
     out("AllocateShapeSpec");
     return true;
   }
-  bool pre(const AllocateStmt &x) {
+  bool Pre(const AllocateStmt &x) {
     out("AllocateStmt");
     return true;
   }
-  bool pre(const Allocation &x) {
+  bool Pre(const Allocation &x) {
     out("Allocation");
     return true;
   }
-  bool pre(const AltReturnSpec &x) {
+  bool Pre(const AltReturnSpec &x) {
     out("AltReturnSpec");
     return true;
   }
-  bool pre(const ArithmeticIfStmt &x) {
+  bool Pre(const ArithmeticIfStmt &x) {
     out("ArithmeticIfStmt");
     return true;
   }
-  bool pre(const ArrayConstructor &x) {
+  bool Pre(const ArrayConstructor &x) {
     out("ArrayConstructor");
     return true;
   }
-  bool pre(const ArrayElement &x) {
+  bool Pre(const ArrayElement &x) {
     out("ArrayElement");
     return true;
   }
-  bool pre(const ArraySection &x) {
+  bool Pre(const ArraySection &x) {
     out("ArraySection");
     return true;
   }
-  bool pre(const ArraySpec &x) {
+  bool Pre(const ArraySpec &x) {
     out("ArraySpec");
     return true;
   }
-  bool pre(const AssignStmt &x) {
+  bool Pre(const AssignStmt &x) {
     out("AssignStmt");
     return true;
   }
-  bool pre(const AssignedGotoStmt &x) {
+  bool Pre(const AssignedGotoStmt &x) {
     out("AssignedGotoStmt");
     return true;
   }
-  bool pre(const AssignmentStmt &x) {
+  bool Pre(const AssignmentStmt &x) {
     out("AssignmentStmt");
     return true;
   }
-  bool pre(const AssociateConstruct &x) {
+  bool Pre(const AssociateConstruct &x) {
     out("AssociateConstruct");
     return true;
   }
-  bool pre(const AssociateStmt &x) {
+  bool Pre(const AssociateStmt &x) {
     out("AssociateStmt");
     return true;
   }
-  bool pre(const Association &x) {
+  bool Pre(const Association &x) {
     out("Association");
     return true;
   }
-  bool pre(const AssumedImpliedSpec &x) {
+  bool Pre(const AssumedImpliedSpec &x) {
     out("AssumedImpliedSpec");
     return true;
   }
-  bool pre(const AssumedRankSpec &x) {
+  bool Pre(const AssumedRankSpec &x) {
     out("AssumedRankSpec");
     return true;
   }
-  bool pre(const AssumedShapeSpec &x) {
+  bool Pre(const AssumedShapeSpec &x) {
     out("AssumedShapeSpec");
     return true;
   }
-  bool pre(const AssumedSizeSpec &x) {
+  bool Pre(const AssumedSizeSpec &x) {
     out("AssumedSizeSpec");
     return true;
   }
-  bool pre(const Asynchronous &x) {
+  bool Pre(const Asynchronous &x) {
     out("Asynchronous");
     return true;
   }
-  bool pre(const AsynchronousStmt &x) {
+  bool Pre(const AsynchronousStmt &x) {
     out("AsynchronousStmt");
     return true;
   }
-  bool pre(const AttrSpec &x) {
+  bool Pre(const AttrSpec &x) {
     out("AttrSpec");
     return true;
   }
-  bool pre(const BOZLiteralConstant &x) {
+  bool Pre(const BOZLiteralConstant &x) {
     out("BOZLiteralConstant");
     return true;
   }
-  bool pre(const BackspaceStmt &x) {
+  bool Pre(const BackspaceStmt &x) {
     out("BackspaceStmt");
     return true;
   }
-  bool pre(const BasedPointerStmt &x) {
+  bool Pre(const BasedPointerStmt &x) {
     out("BasedPointerStmt");
     return true;
   }
-  bool pre(const BindAttr &x) {
+  bool Pre(const BindAttr &x) {
     out("BindAttr");
     return true;
   }
-  bool pre(const BindAttr::Deferred &x) {
+  bool Pre(const BindAttr::Deferred &x) {
     out("BindAttr::Deferred");
     return true;
   }
-  bool pre(const BindAttr::Non_Overridable &x) {
+  bool Pre(const BindAttr::Non_Overridable &x) {
     out("BindAttr::Non_Overridable");
     return true;
   }
-  bool pre(const BindEntity &x) {
+  bool Pre(const BindEntity &x) {
     out("BindEntity");
     return true;
   }
-  bool pre(const BindStmt &x) {
+  bool Pre(const BindStmt &x) {
     out("BindStmt");
     return true;
   }
-  bool pre(const BlockConstruct &x) {
+  bool Pre(const BlockConstruct &x) {
     out("BlockConstruct");
     return true;
   }
-  bool pre(const BlockData &x) {
+  bool Pre(const BlockData &x) {
     out("BlockData");
     return true;
   }
-  bool pre(const BlockDataStmt &x) {
+  bool Pre(const BlockDataStmt &x) {
     out("BlockDataStmt");
     return true;
   }
-  bool pre(const BlockSpecificationPart &x) {
+  bool Pre(const BlockSpecificationPart &x) {
     out("BlockSpecificationPart");
     return true;
   }
-  bool pre(const BlockStmt &x) {
+  bool Pre(const BlockStmt &x) {
     out("BlockStmt");
     return true;
   }
-  bool pre(const BoundsRemapping &x) {
+  bool Pre(const BoundsRemapping &x) {
     out("BoundsRemapping");
     return true;
   }
-  bool pre(const BoundsSpec &x) {
+  bool Pre(const BoundsSpec &x) {
     out("BoundsSpec");
     return true;
   }
-  bool pre(const Call &x) {
+  bool Pre(const Call &x) {
     out("Call");
     return true;
   }
-  bool pre(const CallStmt &x) {
+  bool Pre(const CallStmt &x) {
     out("CallStmt");
     return true;
   }
-  bool pre(const CaseConstruct &x) {
+  bool Pre(const CaseConstruct &x) {
     out("CaseConstruct");
     return true;
   }
-  bool pre(const CaseConstruct::Case &x) {
+  bool Pre(const CaseConstruct::Case &x) {
     out("CaseConstruct::Case");
     return true;
   }
-  bool pre(const CaseSelector &x) {
+  bool Pre(const CaseSelector &x) {
     out("CaseSelector");
     return true;
   }
-  bool pre(const CaseStmt &x) {
+  bool Pre(const CaseStmt &x) {
     out("CaseStmt");
     return true;
   }
-  bool pre(const CaseValueRange &x) {
+  bool Pre(const CaseValueRange &x) {
     out("CaseValueRange");
     return true;
   }
-  bool pre(const CaseValueRange::Range &x) {
+  bool Pre(const CaseValueRange::Range &x) {
     out("CaseValueRange::Range");
     return true;
   }
-  bool pre(const ChangeTeamConstruct &x) {
+  bool Pre(const ChangeTeamConstruct &x) {
     out("ChangeTeamConstruct");
     return true;
   }
-  bool pre(const ChangeTeamStmt &x) {
+  bool Pre(const ChangeTeamStmt &x) {
     out("ChangeTeamStmt");
     return true;
   }
-  bool pre(const CharLength &x) {
+  bool Pre(const CharLength &x) {
     out("CharLength");
     return true;
   }
-  bool pre(const CharLiteralConstant &x) {
+  bool Pre(const CharLiteralConstant &x) {
     out("CharLiteralConstant");
     return true;
   }
-  bool pre(const CharLiteralConstantSubstring &x) {
+  bool Pre(const CharLiteralConstantSubstring &x) {
     out("CharLiteralConstantSubstring");
     return true;
   }
-  bool pre(const CharSelector &x) {
+  bool Pre(const CharSelector &x) {
     out("CharSelector");
     return true;
   }
-  bool pre(const CharSelector::LengthAndKind &x) {
+  bool Pre(const CharSelector::LengthAndKind &x) {
     out("CharSelector::LengthAndKind");
     return true;
   }
-  bool pre(const CharVariable &x) {
+  bool Pre(const CharVariable &x) {
     out("CharVariable");
     return true;
   }
-  bool pre(const CloseStmt &x) {
+  bool Pre(const CloseStmt &x) {
     out("CloseStmt");
     return true;
   }
-  bool pre(const CloseStmt::CloseSpec &x) {
+  bool Pre(const CloseStmt::CloseSpec &x) {
     out("CloseStmt::CloseSpec");
     return true;
   }
-  bool pre(const CoarrayAssociation &x) {
+  bool Pre(const CoarrayAssociation &x) {
     out("CoarrayAssociation");
     return true;
   }
-  bool pre(const CoarraySpec &x) {
+  bool Pre(const CoarraySpec &x) {
     out("CoarraySpec");
     return true;
   }
-  bool pre(const CodimensionDecl &x) {
+  bool Pre(const CodimensionDecl &x) {
     out("CodimensionDecl");
     return true;
   }
-  bool pre(const CodimensionStmt &x) {
+  bool Pre(const CodimensionStmt &x) {
     out("CodimensionStmt");
     return true;
   }
-  bool pre(const CoindexedNamedObject &x) {
+  bool Pre(const CoindexedNamedObject &x) {
     out("CoindexedNamedObject");
     return true;
   }
-  bool pre(const CommonBlockObject &x) {
+  bool Pre(const CommonBlockObject &x) {
     out("CommonBlockObject");
     return true;
   }
-  bool pre(const CommonStmt &x) {
+  bool Pre(const CommonStmt &x) {
     out("CommonStmt");
     return true;
   }
-  bool pre(const ComplexLiteralConstant &x) {
+  bool Pre(const ComplexLiteralConstant &x) {
     out("ComplexLiteralConstant");
     return true;
   }
-  bool pre(const ComplexPart &x) {
+  bool Pre(const ComplexPart &x) {
     out("ComplexPart");
     return true;
   }
-  bool pre(const ComplexPartDesignator &x) {
+  bool Pre(const ComplexPartDesignator &x) {
     out("ComplexPartDesignator");
     return true;
   }
-  bool pre(const ComponentArraySpec &x) {
+  bool Pre(const ComponentArraySpec &x) {
     out("ComponentArraySpec");
     return true;
   }
-  bool pre(const ComponentAttrSpec &x) {
+  bool Pre(const ComponentAttrSpec &x) {
     out("ComponentAttrSpec");
     return true;
   }
-  bool pre(const ComponentDataSource &x) {
+  bool Pre(const ComponentDataSource &x) {
     out("ComponentDataSource");
     return true;
   }
-  bool pre(const ComponentDecl &x) {
+  bool Pre(const ComponentDecl &x) {
     out("ComponentDecl");
     return true;
   }
-  bool pre(const ComponentDefStmt &x) {
+  bool Pre(const ComponentDefStmt &x) {
     out("ComponentDefStmt");
     return true;
   }
-  bool pre(const ComponentSpec &x) {
+  bool Pre(const ComponentSpec &x) {
     out("ComponentSpec");
     return true;
   }
-  bool pre(const ComputedGotoStmt &x) {
+  bool Pre(const ComputedGotoStmt &x) {
     out("ComputedGotoStmt");
     return true;
   }
-  bool pre(const ConcurrentControl &x) {
+  bool Pre(const ConcurrentControl &x) {
     out("ConcurrentControl");
     return true;
   }
-  bool pre(const ConcurrentHeader &x) {
+  bool Pre(const ConcurrentHeader &x) {
     out("ConcurrentHeader");
     return true;
   }
-  bool pre(const ConnectSpec &x) {
+  bool Pre(const ConnectSpec &x) {
     out("ConnectSpec");
     return true;
   }
-  bool pre(const ConnectSpec::CharExpr &x) {
+  bool Pre(const ConnectSpec::CharExpr &x) {
     out("ConnectSpec::CharExpr");
     return true;
   }
-  bool pre(const ConnectSpec::Newunit &x) {
+  bool Pre(const ConnectSpec::Newunit &x) {
     out("ConnectSpec::Newunit");
     return true;
   }
-  bool pre(const ConnectSpec::Recl &x) {
+  bool Pre(const ConnectSpec::Recl &x) {
     out("ConnectSpec::Recl");
     return true;
   }
-  bool pre(const ConstantValue &x) {
+  bool Pre(const ConstantValue &x) {
     out("ConstantValue");
     return true;
   }
-  bool pre(const ContainsStmt &x) {
+  bool Pre(const ContainsStmt &x) {
     out("ContainsStmt");
     return true;
   }
-  bool pre(const Contiguous &x) {
+  bool Pre(const Contiguous &x) {
     out("Contiguous");
     return true;
   }
-  bool pre(const ContiguousStmt &x) {
+  bool Pre(const ContiguousStmt &x) {
     out("ContiguousStmt");
     return true;
   }
-  bool pre(const ContinueStmt &x) {
+  bool Pre(const ContinueStmt &x) {
     out("ContinueStmt");
     return true;
   }
-  bool pre(const CriticalConstruct &x) {
+  bool Pre(const CriticalConstruct &x) {
     out("CriticalConstruct");
     return true;
   }
-  bool pre(const CriticalStmt &x) {
+  bool Pre(const CriticalStmt &x) {
     out("CriticalStmt");
     return true;
   }
-  bool pre(const CycleStmt &x) {
+  bool Pre(const CycleStmt &x) {
     out("CycleStmt");
     return true;
   }
-  bool pre(const DataComponentDefStmt &x) {
+  bool Pre(const DataComponentDefStmt &x) {
     out("DataComponentDefStmt");
     return true;
   }
-  bool pre(const DataIDoObject &x) {
+  bool Pre(const DataIDoObject &x) {
     out("DataIDoObject");
     return true;
   }
-  bool pre(const DataImpliedDo &x) {
+  bool Pre(const DataImpliedDo &x) {
     out("DataImpliedDo");
     return true;
   }
-  bool pre(const DataReference &x) {
+  bool Pre(const DataReference &x) {
     out("DataReference");
     return true;
   }
-  bool pre(const DataStmt &x) {
+  bool Pre(const DataStmt &x) {
     out("DataStmt");
     return true;
   }
-  bool pre(const DataStmtConstant &x) {
+  bool Pre(const DataStmtConstant &x) {
     out("DataStmtConstant");
     return true;
   }
-  bool pre(const DataStmtObject &x) {
+  bool Pre(const DataStmtObject &x) {
     out("DataStmtObject");
     return true;
   }
-  bool pre(const DataStmtRepeat &x) {
+  bool Pre(const DataStmtRepeat &x) {
     out("DataStmtRepeat");
     return true;
   }
-  bool pre(const DataStmtSet &x) {
+  bool Pre(const DataStmtSet &x) {
     out("DataStmtSet");
     return true;
   }
-  bool pre(const DataStmtValue &x) {
+  bool Pre(const DataStmtValue &x) {
     out("DataStmtValue");
     return true;
   }
-  bool pre(const DeallocateStmt &x) {
+  bool Pre(const DeallocateStmt &x) {
     out("DeallocateStmt");
     return true;
   }
-  bool pre(const DeclarationConstruct &x) {
+  bool Pre(const DeclarationConstruct &x) {
     out("DeclarationConstruct");
     return true;
   }
-  bool pre(const DeclarationTypeSpec &x) {
+  bool Pre(const DeclarationTypeSpec &x) {
     out("DeclarationTypeSpec");
     return true;
   }
-  bool pre(const DeclarationTypeSpec::Class &x) {
+  bool Pre(const DeclarationTypeSpec::Class &x) {
     out("DeclarationTypeSpec::Class");
     return true;
   }
-  bool pre(const DeclarationTypeSpec::ClassStar &x) {
+  bool Pre(const DeclarationTypeSpec::ClassStar &x) {
     out("DeclarationTypeSpec::ClassStar");
     return true;
   }
-  bool pre(const DeclarationTypeSpec::Record &x) {
+  bool Pre(const DeclarationTypeSpec::Record &x) {
     out("DeclarationTypeSpec::Record");
     return true;
   }
-  bool pre(const DeclarationTypeSpec::Type &x) {
+  bool Pre(const DeclarationTypeSpec::Type &x) {
     out("DeclarationTypeSpec::Type");
     return true;
   }
-  bool pre(const DeclarationTypeSpec::TypeStar &x) {
+  bool Pre(const DeclarationTypeSpec::TypeStar &x) {
     out("DeclarationTypeSpec::TypeStar");
     return true;
   }
-  bool pre(const Default &x) {
+  bool Pre(const Default &x) {
     out("Default");
     return true;
   }
-  bool pre(const DeferredCoshapeSpecList &x) {
+  bool Pre(const DeferredCoshapeSpecList &x) {
     out("DeferredCoshapeSpecList");
     return true;
   }
-  bool pre(const DeferredShapeSpecList &x) {
+  bool Pre(const DeferredShapeSpecList &x) {
     out("DeferredShapeSpecList");
     return true;
   }
-  bool pre(const DefinedOpName &x) {
+  bool Pre(const DefinedOpName &x) {
     out("DefinedOpName");
     return true;
   }
-  bool pre(const DefinedOperator &x) {
+  bool Pre(const DefinedOperator &x) {
     out("DefinedOperator");
     return true;
   }
-  bool pre(const DerivedTypeDef &x) {
+  bool Pre(const DerivedTypeDef &x) {
     out("DerivedTypeDef");
     return true;
   }
-  bool pre(const DerivedTypeSpec &x) {
+  bool Pre(const DerivedTypeSpec &x) {
     out("DerivedTypeSpec");
     return true;
   }
-  bool pre(const DerivedTypeStmt &x) {
+  bool Pre(const DerivedTypeStmt &x) {
     out("DerivedTypeStmt");
     return true;
   }
-  bool pre(const Designator &x) {
+  bool Pre(const Designator &x) {
     out("Designator");
     return true;
   }
-  bool pre(const DimensionStmt &x) {
+  bool Pre(const DimensionStmt &x) {
     out("DimensionStmt");
     return true;
   }
-  bool pre(const DimensionStmt::Declaration &x) {
+  bool Pre(const DimensionStmt::Declaration &x) {
     out("DimensionStmt::Declaration");
     return true;
   }
-  bool pre(const DoConstruct &x) {
+  bool Pre(const DoConstruct &x) {
     out("DoConstruct");
     return true;
   }
-  bool pre(const DummyArg &x) {
+  bool Pre(const DummyArg &x) {
     out("DummyArg");
     return true;
   }
-  bool pre(const ElseIfStmt &x) {
+  bool Pre(const ElseIfStmt &x) {
     out("ElseIfStmt");
     return true;
   }
-  bool pre(const ElseStmt &x) {
+  bool Pre(const ElseStmt &x) {
     out("ElseStmt");
     return true;
   }
-  bool pre(const ElsewhereStmt &x) {
+  bool Pre(const ElsewhereStmt &x) {
     out("ElsewhereStmt");
     return true;
   }
-  bool pre(const EndAssociateStmt &x) {
+  bool Pre(const EndAssociateStmt &x) {
     out("EndAssociateStmt");
     return true;
   }
-  bool pre(const EndBlockDataStmt &x) {
+  bool Pre(const EndBlockDataStmt &x) {
     out("EndBlockDataStmt");
     return true;
   }
-  bool pre(const EndBlockStmt &x) {
+  bool Pre(const EndBlockStmt &x) {
     out("EndBlockStmt");
     return true;
   }
-  bool pre(const EndChangeTeamStmt &x) {
+  bool Pre(const EndChangeTeamStmt &x) {
     out("EndChangeTeamStmt");
     return true;
   }
-  bool pre(const EndCriticalStmt &x) {
+  bool Pre(const EndCriticalStmt &x) {
     out("EndCriticalStmt");
     return true;
   }
-  bool pre(const EndDoStmt &x) {
+  bool Pre(const EndDoStmt &x) {
     out("EndDoStmt");
     return true;
   }
-  bool pre(const EndEnumStmt &x) {
+  bool Pre(const EndEnumStmt &x) {
     out("EndEnumStmt");
     return true;
   }
-  bool pre(const EndForallStmt &x) {
+  bool Pre(const EndForallStmt &x) {
     out("EndForallStmt");
     return true;
   }
-  bool pre(const EndFunctionStmt &x) {
+  bool Pre(const EndFunctionStmt &x) {
     out("EndFunctionStmt");
     return true;
   }
-  bool pre(const EndIfStmt &x) {
+  bool Pre(const EndIfStmt &x) {
     out("EndIfStmt");
     return true;
   }
-  bool pre(const EndInterfaceStmt &x) {
+  bool Pre(const EndInterfaceStmt &x) {
     out("EndInterfaceStmt");
     return true;
   }
-  bool pre(const EndLabel &x) {
+  bool Pre(const EndLabel &x) {
     out("EndLabel");
     return true;
   }
-  bool pre(const EndModuleStmt &x) {
+  bool Pre(const EndModuleStmt &x) {
     out("EndModuleStmt");
     return true;
   }
-  bool pre(const EndMpSubprogramStmt &x) {
+  bool Pre(const EndMpSubprogramStmt &x) {
     out("EndMpSubprogramStmt");
     return true;
   }
-  bool pre(const EndProgramStmt &x) {
+  bool Pre(const EndProgramStmt &x) {
     out("EndProgramStmt");
     return true;
   }
-  bool pre(const EndSelectStmt &x) {
+  bool Pre(const EndSelectStmt &x) {
     out("EndSelectStmt");
     return true;
   }
-  bool pre(const EndSubmoduleStmt &x) {
+  bool Pre(const EndSubmoduleStmt &x) {
     out("EndSubmoduleStmt");
     return true;
   }
-  bool pre(const EndSubroutineStmt &x) {
+  bool Pre(const EndSubroutineStmt &x) {
     out("EndSubroutineStmt");
     return true;
   }
-  bool pre(const EndTypeStmt &x) {
+  bool Pre(const EndTypeStmt &x) {
     out("EndTypeStmt");
     return true;
   }
-  bool pre(const EndWhereStmt &x) {
+  bool Pre(const EndWhereStmt &x) {
     out("EndWhereStmt");
     return true;
   }
-  bool pre(const EndfileStmt &x) {
+  bool Pre(const EndfileStmt &x) {
     out("EndfileStmt");
     return true;
   }
-  bool pre(const EntityDecl &x) {
+  bool Pre(const EntityDecl &x) {
     out("EntityDecl");
     return true;
   }
-  bool pre(const EntryStmt &x) {
+  bool Pre(const EntryStmt &x) {
     out("EntryStmt");
     return true;
   }
-  bool pre(const EnumDef &x) {
+  bool Pre(const EnumDef &x) {
     out("EnumDef");
     return true;
   }
-  bool pre(const EnumDefStmt &x) {
+  bool Pre(const EnumDefStmt &x) {
     out("EnumDefStmt");
     return true;
   }
-  bool pre(const Enumerator &x) {
+  bool Pre(const Enumerator &x) {
     out("Enumerator");
     return true;
   }
-  bool pre(const EnumeratorDefStmt &x) {
+  bool Pre(const EnumeratorDefStmt &x) {
     out("EnumeratorDefStmt");
     return true;
   }
-  bool pre(const EorLabel &x) {
+  bool Pre(const EorLabel &x) {
     out("EorLabel");
     return true;
   }
-  bool pre(const EquivalenceObject &x) {
+  bool Pre(const EquivalenceObject &x) {
     out("EquivalenceObject");
     return true;
   }
-  bool pre(const EquivalenceStmt &x) {
+  bool Pre(const EquivalenceStmt &x) {
     out("EquivalenceStmt");
     return true;
   }
-  bool pre(const ErrLabel &x) {
+  bool Pre(const ErrLabel &x) {
     out("ErrLabel");
     return true;
   }
-  bool pre(const ErrorRecovery &x) {
+  bool Pre(const ErrorRecovery &x) {
     out("ErrorRecovery");
     return true;
   }
-  bool pre(const EventPostStmt &x) {
+  bool Pre(const EventPostStmt &x) {
     out("EventPostStmt");
     return true;
   }
-  bool pre(const EventWaitStmt &x) {
+  bool Pre(const EventWaitStmt &x) {
     out("EventWaitStmt");
     return true;
   }
-  bool pre(const EventWaitStmt::EventWaitSpec &x) {
+  bool Pre(const EventWaitStmt::EventWaitSpec &x) {
     out("EventWaitStmt::EventWaitSpec");
     return true;
   }
-  bool pre(const ExecutableConstruct &x) {
+  bool Pre(const ExecutableConstruct &x) {
     out("ExecutableConstruct");
     return true;
   }
-  bool pre(const ExecutionPartConstruct &x) {
+  bool Pre(const ExecutionPartConstruct &x) {
     out("ExecutionPartConstruct");
     return true;
   }
-  bool pre(const ExitStmt &x) {
+  bool Pre(const ExitStmt &x) {
     out("ExitStmt");
     return true;
   }
-  bool pre(const ExplicitCoshapeSpec &x) {
+  bool Pre(const ExplicitCoshapeSpec &x) {
     out("ExplicitCoshapeSpec");
     return true;
   }
-  bool pre(const ExplicitShapeSpec &x) {
+  bool Pre(const ExplicitShapeSpec &x) {
     out("ExplicitShapeSpec");
     return true;
   }
-  bool pre(const ExponentPart &x) {
+  bool Pre(const ExponentPart &x) {
     out("ExponentPart");
     return true;
   }
-  bool pre(const Expr &x) {
+  bool Pre(const Expr &x) {
     out("Expr");
     return true;
   }
-  bool pre(const Expr::AND &x) {
+  bool Pre(const Expr::AND &x) {
     out("Expr::AND");
     return true;
   }
-  bool pre(const Expr::Add &x) {
+  bool Pre(const Expr::Add &x) {
     out("Expr::Add");
     return true;
   }
-  bool pre(const Expr::ComplexConstructor &x) {
+  bool Pre(const Expr::ComplexConstructor &x) {
     out("Expr::ComplexConstructor");
     return true;
   }
-  bool pre(const Expr::Concat &x) {
+  bool Pre(const Expr::Concat &x) {
     out("Expr::Concat");
     return true;
   }
-  bool pre(const Expr::DefinedBinary &x) {
+  bool Pre(const Expr::DefinedBinary &x) {
     out("Expr::DefinedBinary");
     return true;
   }
-  bool pre(const Expr::DefinedUnary &x) {
+  bool Pre(const Expr::DefinedUnary &x) {
     out("Expr::DefinedUnary");
     return true;
   }
-  bool pre(const Expr::Divide &x) {
+  bool Pre(const Expr::Divide &x) {
     out("Expr::Divide");
     return true;
   }
-  bool pre(const Expr::EQ &x) {
+  bool Pre(const Expr::EQ &x) {
     out("Expr::EQ");
     return true;
   }
-  bool pre(const Expr::EQV &x) {
+  bool Pre(const Expr::EQV &x) {
     out("Expr::EQV");
     return true;
   }
-  bool pre(const Expr::GE &x) {
+  bool Pre(const Expr::GE &x) {
     out("Expr::GE");
     return true;
   }
-  bool pre(const Expr::GT &x) {
+  bool Pre(const Expr::GT &x) {
     out("Expr::GT");
     return true;
   }
-  bool pre(const Expr::IntrinsicBinary &x) {
+  bool Pre(const Expr::IntrinsicBinary &x) {
     out("Expr::IntrinsicBinary");
     return true;
   }
-  bool pre(const Expr::IntrinsicUnary &x) {
+  bool Pre(const Expr::IntrinsicUnary &x) {
     out("Expr::IntrinsicUnary");
     return true;
   }
-  bool pre(const Expr::LE &x) {
+  bool Pre(const Expr::LE &x) {
     out("Expr::LE");
     return true;
   }
-  bool pre(const Expr::LT &x) {
+  bool Pre(const Expr::LT &x) {
     out("Expr::LT");
     return true;
   }
-  bool pre(const Expr::Multiply &x) {
+  bool Pre(const Expr::Multiply &x) {
     out("Expr::Multiply");
     return true;
   }
-  bool pre(const Expr::NE &x) {
+  bool Pre(const Expr::NE &x) {
     out("Expr::NE");
     return true;
   }
-  bool pre(const Expr::NEQV &x) {
+  bool Pre(const Expr::NEQV &x) {
     out("Expr::NEQV");
     return true;
   }
-  bool pre(const Expr::NOT &x) {
+  bool Pre(const Expr::NOT &x) {
     out("Expr::NOT");
     return true;
   }
-  bool pre(const Expr::Negate &x) {
+  bool Pre(const Expr::Negate &x) {
     out("Expr::Negate");
     return true;
   }
-  bool pre(const Expr::OR &x) {
+  bool Pre(const Expr::OR &x) {
     out("Expr::OR");
     return true;
   }
-  bool pre(const Expr::Parentheses &x) {
+  bool Pre(const Expr::Parentheses &x) {
     out("Expr::Parentheses");
     return true;
   }
-  bool pre(const Expr::PercentLoc &x) {
+  bool Pre(const Expr::PercentLoc &x) {
     out("Expr::PercentLoc");
     return true;
   }
-  bool pre(const Expr::Power &x) {
+  bool Pre(const Expr::Power &x) {
     out("Expr::Power");
     return true;
   }
-  bool pre(const Expr::Subtract &x) {
+  bool Pre(const Expr::Subtract &x) {
     out("Expr::Subtract");
     return true;
   }
-  bool pre(const Expr::UnaryPlus &x) {
+  bool Pre(const Expr::UnaryPlus &x) {
     out("Expr::UnaryPlus");
     return true;
   }
-  bool pre(const External &x) {
+  bool Pre(const External &x) {
     out("External");
     return true;
   }
-  bool pre(const ExternalStmt &x) {
+  bool Pre(const ExternalStmt &x) {
     out("ExternalStmt");
     return true;
   }
-  bool pre(const FailImageStmt &x) {
+  bool Pre(const FailImageStmt &x) {
     out("FailImageStmt");
     return true;
   }
-  bool pre(const FileUnitNumber &x) {
+  bool Pre(const FileUnitNumber &x) {
     out("FileUnitNumber");
     return true;
   }
-  bool pre(const FinalProcedureStmt &x) {
+  bool Pre(const FinalProcedureStmt &x) {
     out("FinalProcedureStmt");
     return true;
   }
-  bool pre(const FlushStmt &x) {
+  bool Pre(const FlushStmt &x) {
     out("FlushStmt");
     return true;
   }
-  bool pre(const ForallAssignmentStmt &x) {
+  bool Pre(const ForallAssignmentStmt &x) {
     out("ForallAssignmentStmt");
     return true;
   }
-  bool pre(const ForallBodyConstruct &x) {
+  bool Pre(const ForallBodyConstruct &x) {
     out("ForallBodyConstruct");
     return true;
   }
-  bool pre(const ForallConstruct &x) {
+  bool Pre(const ForallConstruct &x) {
     out("ForallConstruct");
     return true;
   }
-  bool pre(const ForallConstructStmt &x) {
+  bool Pre(const ForallConstructStmt &x) {
     out("ForallConstructStmt");
     return true;
   }
-  bool pre(const ForallStmt &x) {
+  bool Pre(const ForallStmt &x) {
     out("ForallStmt");
     return true;
   }
-  bool pre(const FormTeamStmt &x) {
+  bool Pre(const FormTeamStmt &x) {
     out("FormTeamStmt");
     return true;
   }
-  bool pre(const FormTeamStmt::FormTeamSpec &x) {
+  bool Pre(const FormTeamStmt::FormTeamSpec &x) {
     out("FormTeamStmt::FormTeamSpec");
     return true;
   }
-  bool pre(const Format &x) {
+  bool Pre(const Format &x) {
     out("Format");
     return true;
   }
-  bool pre(const FormatStmt &x) {
+  bool Pre(const FormatStmt &x) {
     out("FormatStmt");
     return true;
   }
-  bool pre(const Fortran::ControlEditDesc &x) {
+  bool Pre(const Fortran::ControlEditDesc &x) {
     out("Fortran::ControlEditDesc");
     return true;
   }
-  bool pre(const Fortran::DerivedTypeDataEditDesc &x) {
+  bool Pre(const Fortran::DerivedTypeDataEditDesc &x) {
     out("Fortran::DerivedTypeDataEditDesc");
     return true;
   }
-  bool pre(const Fortran::FormatItem &x) {
+  bool Pre(const Fortran::FormatItem &x) {
     out("Fortran::FormatItem");
     return true;
   }
-  bool pre(const Fortran::FormatSpecification &x) {
+  bool Pre(const Fortran::FormatSpecification &x) {
     out("Fortran::FormatSpecification");
     return true;
   }
-  bool pre(const Fortran::IntrinsicTypeDataEditDesc &x) {
+  bool Pre(const Fortran::IntrinsicTypeDataEditDesc &x) {
     out("Fortran::IntrinsicTypeDataEditDesc");
     return true;
   }
-  bool pre(const FunctionReference &x) {
+  bool Pre(const FunctionReference &x) {
     out("FunctionReference");
     return true;
   }
-  bool pre(const FunctionStmt &x) {
+  bool Pre(const FunctionStmt &x) {
     out("FunctionStmt");
     return true;
   }
-  bool pre(const FunctionSubprogram &x) {
+  bool Pre(const FunctionSubprogram &x) {
     out("FunctionSubprogram");
     return true;
   }
-  bool pre(const GenericSpec &x) {
+  bool Pre(const GenericSpec &x) {
     out("GenericSpec");
     return true;
   }
-  bool pre(const GenericSpec::Assignment &x) {
+  bool Pre(const GenericSpec::Assignment &x) {
     out("GenericSpec::Assignment");
     return true;
   }
-  bool pre(const GenericSpec::ReadFormatted &x) {
+  bool Pre(const GenericSpec::ReadFormatted &x) {
     out("GenericSpec::ReadFormatted");
     return true;
   }
-  bool pre(const GenericSpec::ReadUnformatted &x) {
+  bool Pre(const GenericSpec::ReadUnformatted &x) {
     out("GenericSpec::ReadUnformatted");
     return true;
   }
-  bool pre(const GenericSpec::WriteFormatted &x) {
+  bool Pre(const GenericSpec::WriteFormatted &x) {
     out("GenericSpec::WriteFormatted");
     return true;
   }
-  bool pre(const GenericSpec::WriteUnformatted &x) {
+  bool Pre(const GenericSpec::WriteUnformatted &x) {
     out("GenericSpec::WriteUnformatted");
     return true;
   }
-  bool pre(const GenericStmt &x) {
+  bool Pre(const GenericStmt &x) {
     out("GenericStmt");
     return true;
   }
-  bool pre(const GotoStmt &x) {
+  bool Pre(const GotoStmt &x) {
     out("GotoStmt");
     return true;
   }
-  bool pre(const HollerithLiteralConstant &x) {
+  bool Pre(const HollerithLiteralConstant &x) {
     out("HollerithLiteralConstant");
     return true;
   }
-  bool pre(const IdExpr &x) {
+  bool Pre(const IdExpr &x) {
     out("IdExpr");
     return true;
   }
-  bool pre(const IdVariable &x) {
+  bool Pre(const IdVariable &x) {
     out("IdVariable");
     return true;
   }
-  bool pre(const IfConstruct &x) {
+  bool Pre(const IfConstruct &x) {
     out("IfConstruct");
     return true;
   }
-  bool pre(const IfConstruct::ElseBlock &x) {
+  bool Pre(const IfConstruct::ElseBlock &x) {
     out("IfConstruct::ElseBlock");
     return true;
   }
-  bool pre(const IfConstruct::ElseIfBlock &x) {
+  bool Pre(const IfConstruct::ElseIfBlock &x) {
     out("IfConstruct::ElseIfBlock");
     return true;
   }
-  bool pre(const IfStmt &x) {
+  bool Pre(const IfStmt &x) {
     out("IfStmt");
     return true;
   }
-  bool pre(const IfThenStmt &x) {
+  bool Pre(const IfThenStmt &x) {
     out("IfThenStmt");
     return true;
   }
-  bool pre(const ImageSelector &x) {
+  bool Pre(const ImageSelector &x) {
     out("ImageSelector");
     return true;
   }
-  bool pre(const ImageSelectorSpec &x) {
+  bool Pre(const ImageSelectorSpec &x) {
     out("ImageSelectorSpec");
     return true;
   }
-  bool pre(const ImageSelectorSpec::Stat &x) {
+  bool Pre(const ImageSelectorSpec::Stat &x) {
     out("ImageSelectorSpec::Stat");
     return true;
   }
-  bool pre(const ImageSelectorSpec::Team &x) {
+  bool Pre(const ImageSelectorSpec::Team &x) {
     out("ImageSelectorSpec::Team");
     return true;
   }
-  bool pre(const ImageSelectorSpec::Team_Number &x) {
+  bool Pre(const ImageSelectorSpec::Team_Number &x) {
     out("ImageSelectorSpec::Team_Number");
     return true;
   }
-  bool pre(const ImplicitPart &x) {
+  bool Pre(const ImplicitPart &x) {
     out("ImplicitPart");
     return true;
   }
-  bool pre(const ImplicitPartStmt &x) {
+  bool Pre(const ImplicitPartStmt &x) {
     out("ImplicitPartStmt");
     return true;
   }
-  bool pre(const ImplicitSpec &x) {
+  bool Pre(const ImplicitSpec &x) {
     out("ImplicitSpec");
     return true;
   }
-  bool pre(const ImplicitStmt &x) {
+  bool Pre(const ImplicitStmt &x) {
     out("ImplicitStmt");
     return true;
   }
-  bool pre(const ImpliedShapeSpec &x) {
+  bool Pre(const ImpliedShapeSpec &x) {
     out("ImpliedShapeSpec");
     return true;
   }
-  bool pre(const ImportStmt &x) {
+  bool Pre(const ImportStmt &x) {
     out("ImportStmt");
     return true;
   }
-  bool pre(const Initialization &x) {
+  bool Pre(const Initialization &x) {
     out("Initialization");
     return true;
   }
-  bool pre(const InputImpliedDo &x) {
+  bool Pre(const InputImpliedDo &x) {
     out("InputImpliedDo");
     return true;
   }
-  bool pre(const InputItem &x) {
+  bool Pre(const InputItem &x) {
     out("InputItem");
     return true;
   }
-  bool pre(const InquireSpec &x) {
+  bool Pre(const InquireSpec &x) {
     out("InquireSpec");
     return true;
   }
-  bool pre(const InquireSpec::CharVar &x) {
+  bool Pre(const InquireSpec::CharVar &x) {
     out("InquireSpec::CharVar");
     return true;
   }
-  bool pre(const InquireSpec::IntVar &x) {
+  bool Pre(const InquireSpec::IntVar &x) {
     out("InquireSpec::IntVar");
     return true;
   }
-  bool pre(const InquireSpec::LogVar &x) {
+  bool Pre(const InquireSpec::LogVar &x) {
     out("InquireSpec::LogVar");
     return true;
   }
-  bool pre(const InquireStmt &x) {
+  bool Pre(const InquireStmt &x) {
     out("InquireStmt");
     return true;
   }
-  bool pre(const InquireStmt::Iolength &x) {
+  bool Pre(const InquireStmt::Iolength &x) {
     out("InquireStmt::Iolength");
     return true;
   }
-  bool pre(const IntLiteralConstant &x) {
+  bool Pre(const IntLiteralConstant &x) {
     out("IntLiteralConstant");
     return true;
   }
-  bool pre(const IntegerTypeSpec &x) {
+  bool Pre(const IntegerTypeSpec &x) {
     out("IntegerTypeSpec");
     return true;
   }
-  bool pre(const IntentSpec &x) {
+  bool Pre(const IntentSpec &x) {
     out("IntentSpec");
     return true;
   }
-  bool pre(const IntentStmt &x) {
+  bool Pre(const IntentStmt &x) {
     out("IntentStmt");
     return true;
   }
-  bool pre(const InterfaceBlock &x) {
+  bool Pre(const InterfaceBlock &x) {
     out("InterfaceBlock");
     return true;
   }
-  bool pre(const InterfaceBody &x) {
+  bool Pre(const InterfaceBody &x) {
     out("InterfaceBody");
     return true;
   }
-  bool pre(const InterfaceBody::Function &x) {
+  bool Pre(const InterfaceBody::Function &x) {
     out("InterfaceBody::Function");
     return true;
   }
-  bool pre(const InterfaceBody::Subroutine &x) {
+  bool Pre(const InterfaceBody::Subroutine &x) {
     out("InterfaceBody::Subroutine");
     return true;
   }
-  bool pre(const InterfaceSpecification &x) {
+  bool Pre(const InterfaceSpecification &x) {
     out("InterfaceSpecification");
     return true;
   }
-  bool pre(const InterfaceStmt &x) {
+  bool Pre(const InterfaceStmt &x) {
     out("InterfaceStmt");
     return true;
   }
-  bool pre(const InternalSubprogram &x) {
+  bool Pre(const InternalSubprogram &x) {
     out("InternalSubprogram");
     return true;
   }
-  bool pre(const InternalSubprogramPart &x) {
+  bool Pre(const InternalSubprogramPart &x) {
     out("InternalSubprogramPart");
     return true;
   }
-  bool pre(const Intrinsic &x) {
+  bool Pre(const Intrinsic &x) {
     out("Intrinsic");
     return true;
   }
-  bool pre(const IntrinsicStmt &x) {
+  bool Pre(const IntrinsicStmt &x) {
     out("IntrinsicStmt");
     return true;
   }
-  bool pre(const IntrinsicTypeSpec &x) {
+  bool Pre(const IntrinsicTypeSpec &x) {
     out("IntrinsicTypeSpec");
     return true;
   }
-  bool pre(const IntrinsicTypeSpec::Character &x) {
+  bool Pre(const IntrinsicTypeSpec::Character &x) {
     out("IntrinsicTypeSpec::Character");
     return true;
   }
-  bool pre(const IntrinsicTypeSpec::Complex &x) {
+  bool Pre(const IntrinsicTypeSpec::Complex &x) {
     out("IntrinsicTypeSpec::Complex");
     return true;
   }
-  bool pre(const IntrinsicTypeSpec::DoubleComplex &x) {
+  bool Pre(const IntrinsicTypeSpec::DoubleComplex &x) {
     out("IntrinsicTypeSpec::DoubleComplex");
     return true;
   }
-  bool pre(const IntrinsicTypeSpec::DoublePrecision &x) {
+  bool Pre(const IntrinsicTypeSpec::DoublePrecision &x) {
     out("IntrinsicTypeSpec::DoublePrecision");
     return true;
   }
-  bool pre(const IntrinsicTypeSpec::Logical &x) {
+  bool Pre(const IntrinsicTypeSpec::Logical &x) {
     out("IntrinsicTypeSpec::Logical");
     return true;
   }
-  bool pre(const IntrinsicTypeSpec::NCharacter &x) {
+  bool Pre(const IntrinsicTypeSpec::NCharacter &x) {
     out("IntrinsicTypeSpec::NCharacter");
     return true;
   }
-  bool pre(const IntrinsicTypeSpec::Real &x) {
+  bool Pre(const IntrinsicTypeSpec::Real &x) {
     out("IntrinsicTypeSpec::Real");
     return true;
   }
-  bool pre(const IoControlSpec &x) {
+  bool Pre(const IoControlSpec &x) {
     out("IoControlSpec");
     return true;
   }
-  bool pre(const IoControlSpec::Asynchronous &x) {
+  bool Pre(const IoControlSpec::Asynchronous &x) {
     out("IoControlSpec::Asynchronous");
     return true;
   }
-  bool pre(const IoControlSpec::CharExpr &x) {
+  bool Pre(const IoControlSpec::CharExpr &x) {
     out("IoControlSpec::CharExpr");
     return true;
   }
-  bool pre(const IoControlSpec::Pos &x) {
+  bool Pre(const IoControlSpec::Pos &x) {
     out("IoControlSpec::Pos");
     return true;
   }
-  bool pre(const IoControlSpec::Rec &x) {
+  bool Pre(const IoControlSpec::Rec &x) {
     out("IoControlSpec::Rec");
     return true;
   }
-  bool pre(const IoControlSpec::Size &x) {
+  bool Pre(const IoControlSpec::Size &x) {
     out("IoControlSpec::Size");
     return true;
   }
-  bool pre(const IoUnit &x) {
+  bool Pre(const IoUnit &x) {
     out("IoUnit");
     return true;
   }
-  bool pre(const KindParam &x) {
+  bool Pre(const KindParam &x) {
     out("KindParam");
     return true;
   }
-  bool pre(const KindParam::Kanji &x) {
+  bool Pre(const KindParam::Kanji &x) {
     out("KindParam::Kanji");
     return true;
   }
-  bool pre(const KindSelector &x) {
+  bool Pre(const KindSelector &x) {
     out("KindSelector");
     return true;
   }
-  bool pre(const LabelDoStmt &x) {
+  bool Pre(const LabelDoStmt &x) {
     out("LabelDoStmt");
     return true;
   }
-  bool pre(const LanguageBindingSpec &x) {
+  bool Pre(const LanguageBindingSpec &x) {
     out("LanguageBindingSpec");
     return true;
   }
-  bool pre(const LengthSelector &x) {
+  bool Pre(const LengthSelector &x) {
     out("LengthSelector");
     return true;
   }
-  bool pre(const LetterSpec &x) {
+  bool Pre(const LetterSpec &x) {
     out("LetterSpec");
     return true;
   }
-  bool pre(const LiteralConstant &x) {
+  bool Pre(const LiteralConstant &x) {
     out("LiteralConstant");
     return true;
   }
-  bool pre(const LocalitySpec &x) {
+  bool Pre(const LocalitySpec &x) {
     out("LocalitySpec");
     return true;
   }
-  bool pre(const LocalitySpec::DefaultNone &x) {
+  bool Pre(const LocalitySpec::DefaultNone &x) {
     out("LocalitySpec::DefaultNone");
     return true;
   }
-  bool pre(const LocalitySpec::Local &x) {
+  bool Pre(const LocalitySpec::Local &x) {
     out("LocalitySpec::Local");
     return true;
   }
-  bool pre(const LocalitySpec::LocalInit &x) {
+  bool Pre(const LocalitySpec::LocalInit &x) {
     out("LocalitySpec::LocalInit");
     return true;
   }
-  bool pre(const LocalitySpec::Shared &x) {
+  bool Pre(const LocalitySpec::Shared &x) {
     out("LocalitySpec::Shared");
     return true;
   }
-  bool pre(const LockStmt &x) {
+  bool Pre(const LockStmt &x) {
     out("LockStmt");
     return true;
   }
-  bool pre(const LockStmt::LockStat &x) {
+  bool Pre(const LockStmt::LockStat &x) {
     out("LockStmt::LockStat");
     return true;
   }
-  bool pre(const LogicalLiteralConstant &x) {
+  bool Pre(const LogicalLiteralConstant &x) {
     out("LogicalLiteralConstant");
     return true;
   }
-  bool pre(const LoopControl &x) {
+  bool Pre(const LoopControl &x) {
     out("LoopControl");
     return true;
   }
-  bool pre(const LoopControl::Concurrent &x) {
+  bool Pre(const LoopControl::Concurrent &x) {
     out("LoopControl::Concurrent");
     return true;
   }
-  bool pre(const MainProgram &x) {
+  bool Pre(const MainProgram &x) {
     out("MainProgram");
     return true;
   }
-  bool pre(const Map &x) {
+  bool Pre(const Map &x) {
     out("Map");
     return true;
   }
-  bool pre(const Map::EndMapStmt &x) {
+  bool Pre(const Map::EndMapStmt &x) {
     out("Map::EndMapStmt");
     return true;
   }
-  bool pre(const Map::MapStmt &x) {
+  bool Pre(const Map::MapStmt &x) {
     out("Map::MapStmt");
     return true;
   }
-  bool pre(const MaskedElsewhereStmt &x) {
+  bool Pre(const MaskedElsewhereStmt &x) {
     out("MaskedElsewhereStmt");
     return true;
   }
-  bool pre(const Module &x) {
+  bool Pre(const Module &x) {
     out("Module");
     return true;
   }
-  bool pre(const ModuleStmt &x) {
+  bool Pre(const ModuleStmt &x) {
     out("ModuleStmt");
     return true;
   }
-  bool pre(const ModuleSubprogram &x) {
+  bool Pre(const ModuleSubprogram &x) {
     out("ModuleSubprogram");
     return true;
   }
-  bool pre(const ModuleSubprogramPart &x) {
+  bool Pre(const ModuleSubprogramPart &x) {
     out("ModuleSubprogramPart");
     return true;
   }
-  bool pre(const MpSubprogramStmt &x) {
+  bool Pre(const MpSubprogramStmt &x) {
     out("MpSubprogramStmt");
     return true;
   }
-  bool pre(const MsgVariable &x) {
+  bool Pre(const MsgVariable &x) {
     out("MsgVariable");
     return true;
   }
-  bool pre(const NamedConstant &x) {
+  bool Pre(const NamedConstant &x) {
     out("NamedConstant");
     return true;
   }
-  bool pre(const NamedConstantDef &x) {
+  bool Pre(const NamedConstantDef &x) {
     out("NamedConstantDef");
     return true;
   }
-  bool pre(const NamelistStmt &x) {
+  bool Pre(const NamelistStmt &x) {
     out("NamelistStmt");
     return true;
   }
-  bool pre(const NamelistStmt::Group &x) {
+  bool Pre(const NamelistStmt::Group &x) {
     out("NamelistStmt::Group");
     return true;
   }
-  bool pre(const NoPass &x) {
+  bool Pre(const NoPass &x) {
     out("NoPass");
     return true;
   }
-  bool pre(const NonLabelDoStmt &x) {
+  bool Pre(const NonLabelDoStmt &x) {
     out("NonLabelDoStmt");
     return true;
   }
-  bool pre(const NullInit &x) {
+  bool Pre(const NullInit &x) {
     out("NullInit");
     return true;
   }
-  bool pre(const NullifyStmt &x) {
+  bool Pre(const NullifyStmt &x) {
     out("NullifyStmt");
     return true;
   }
-  bool pre(const ObjectDecl &x) {
+  bool Pre(const ObjectDecl &x) {
     out("ObjectDecl");
     return true;
   }
-  bool pre(const Only &x) {
+  bool Pre(const Only &x) {
     out("Only");
     return true;
   }
-  bool pre(const OpenStmt &x) {
+  bool Pre(const OpenStmt &x) {
     out("OpenStmt");
     return true;
   }
-  bool pre(const Optional &x) {
+  bool Pre(const Optional &x) {
     out("Optional");
     return true;
   }
-  bool pre(const OptionalStmt &x) {
+  bool Pre(const OptionalStmt &x) {
     out("OptionalStmt");
     return true;
   }
-  bool pre(const OtherSpecificationStmt &x) {
+  bool Pre(const OtherSpecificationStmt &x) {
     out("OtherSpecificationStmt");
     return true;
   }
-  bool pre(const OutputImpliedDo &x) {
+  bool Pre(const OutputImpliedDo &x) {
     out("OutputImpliedDo");
     return true;
   }
-  bool pre(const OutputItem &x) {
+  bool Pre(const OutputItem &x) {
     out("OutputItem");
     return true;
   }
-  bool pre(const Parameter &x) {
+  bool Pre(const Parameter &x) {
     out("Parameter");
     return true;
   }
-  bool pre(const ParameterStmt &x) {
+  bool Pre(const ParameterStmt &x) {
     out("ParameterStmt");
     return true;
   }
-  bool pre(const ParentIdentifier &x) {
+  bool Pre(const ParentIdentifier &x) {
     out("ParentIdentifier");
     return true;
   }
-  bool pre(const PartRef &x) {
+  bool Pre(const PartRef &x) {
     out("PartRef");
     return true;
   }
-  bool pre(const Pass &x) {
+  bool Pre(const Pass &x) {
     out("Pass");
     return true;
   }
-  bool pre(const PauseStmt &x) {
+  bool Pre(const PauseStmt &x) {
     out("PauseStmt");
     return true;
   }
-  bool pre(const Pointer &x) {
+  bool Pre(const Pointer &x) {
     out("Pointer");
     return true;
   }
-  bool pre(const PointerAssignmentStmt &x) {
+  bool Pre(const PointerAssignmentStmt &x) {
     out("PointerAssignmentStmt");
     return true;
   }
-  bool pre(const PointerAssignmentStmt::Bounds &x) {
+  bool Pre(const PointerAssignmentStmt::Bounds &x) {
     out("PointerAssignmentStmt::Bounds");
     return true;
   }
-  bool pre(const PointerDecl &x) {
+  bool Pre(const PointerDecl &x) {
     out("PointerDecl");
     return true;
   }
-  bool pre(const PointerObject &x) {
+  bool Pre(const PointerObject &x) {
     out("PointerObject");
     return true;
   }
-  bool pre(const PointerStmt &x) {
+  bool Pre(const PointerStmt &x) {
     out("PointerStmt");
     return true;
   }
-  bool pre(const PositionOrFlushSpec &x) {
+  bool Pre(const PositionOrFlushSpec &x) {
     out("PositionOrFlushSpec");
     return true;
   }
-  bool pre(const PrefixSpec &x) {
+  bool Pre(const PrefixSpec &x) {
     out("PrefixSpec");
     return true;
   }
-  bool pre(const PrefixSpec::Elemental &x) {
+  bool Pre(const PrefixSpec::Elemental &x) {
     out("PrefixSpec::Elemental");
     return true;
   }
-  bool pre(const PrefixSpec::Impure &x) {
+  bool Pre(const PrefixSpec::Impure &x) {
     out("PrefixSpec::Impure");
     return true;
   }
-  bool pre(const PrefixSpec::Module &x) {
+  bool Pre(const PrefixSpec::Module &x) {
     out("PrefixSpec::Module");
     return true;
   }
-  bool pre(const PrefixSpec::Non_Recursive &x) {
+  bool Pre(const PrefixSpec::Non_Recursive &x) {
     out("PrefixSpec::Non_Recursive");
     return true;
   }
-  bool pre(const PrefixSpec::Pure &x) {
+  bool Pre(const PrefixSpec::Pure &x) {
     out("PrefixSpec::Pure");
     return true;
   }
-  bool pre(const PrefixSpec::Recursive &x) {
+  bool Pre(const PrefixSpec::Recursive &x) {
     out("PrefixSpec::Recursive");
     return true;
   }
-  bool pre(const PrintStmt &x) {
+  bool Pre(const PrintStmt &x) {
     out("PrintStmt");
     return true;
   }
-  bool pre(const PrivateOrSequence &x) {
+  bool Pre(const PrivateOrSequence &x) {
     out("PrivateOrSequence");
     return true;
   }
-  bool pre(const PrivateStmt &x) {
+  bool Pre(const PrivateStmt &x) {
     out("PrivateStmt");
     return true;
   }
-  bool pre(const ProcAttrSpec &x) {
+  bool Pre(const ProcAttrSpec &x) {
     out("ProcAttrSpec");
     return true;
   }
-  bool pre(const ProcComponentAttrSpec &x) {
+  bool Pre(const ProcComponentAttrSpec &x) {
     out("ProcComponentAttrSpec");
     return true;
   }
-  bool pre(const ProcComponentDefStmt &x) {
+  bool Pre(const ProcComponentDefStmt &x) {
     out("ProcComponentDefStmt");
     return true;
   }
-  bool pre(const ProcComponentRef &x) {
+  bool Pre(const ProcComponentRef &x) {
     out("ProcComponentRef");
     return true;
   }
-  bool pre(const ProcDecl &x) {
+  bool Pre(const ProcDecl &x) {
     out("ProcDecl");
     return true;
   }
-  bool pre(const ProcInterface &x) {
+  bool Pre(const ProcInterface &x) {
     out("ProcInterface");
     return true;
   }
-  bool pre(const ProcPointerInit &x) {
+  bool Pre(const ProcPointerInit &x) {
     out("ProcPointerInit");
     return true;
   }
-  bool pre(const ProcedureDeclarationStmt &x) {
+  bool Pre(const ProcedureDeclarationStmt &x) {
     out("ProcedureDeclarationStmt");
     return true;
   }
-  bool pre(const ProcedureDesignator &x) {
+  bool Pre(const ProcedureDesignator &x) {
     out("ProcedureDesignator");
     return true;
   }
-  bool pre(const ProcedureStmt &x) {
+  bool Pre(const ProcedureStmt &x) {
     out("ProcedureStmt");
     return true;
   }
-  bool pre(const Program &x) {
+  bool Pre(const Program &x) {
     out("Program");
     return true;
   }
-  bool pre(const ProgramUnit &x) {
+  bool Pre(const ProgramUnit &x) {
     out("ProgramUnit");
     return true;
   }
-  bool pre(const Protected &x) {
+  bool Pre(const Protected &x) {
     out("Protected");
     return true;
   }
-  bool pre(const ProtectedStmt &x) {
+  bool Pre(const ProtectedStmt &x) {
     out("ProtectedStmt");
     return true;
   }
-  bool pre(const ReadStmt &x) {
+  bool Pre(const ReadStmt &x) {
     out("ReadStmt");
     return true;
   }
-  bool pre(const RealLiteralConstant &x) {
+  bool Pre(const RealLiteralConstant &x) {
     out("RealLiteralConstant");
     return true;
   }
-  bool pre(const RedimensionStmt &x) {
+  bool Pre(const RedimensionStmt &x) {
     out("RedimensionStmt");
     return true;
   }
-  bool pre(const Rename &x) {
+  bool Pre(const Rename &x) {
     out("Rename");
     return true;
   }
-  bool pre(const Rename::Names &x) {
+  bool Pre(const Rename::Names &x) {
     out("Rename::Names");
     return true;
   }
-  bool pre(const Rename::Operators &x) {
+  bool Pre(const Rename::Operators &x) {
     out("Rename::Operators");
     return true;
   }
-  bool pre(const ReturnStmt &x) {
+  bool Pre(const ReturnStmt &x) {
     out("ReturnStmt");
     return true;
   }
-  bool pre(const RewindStmt &x) {
+  bool Pre(const RewindStmt &x) {
     out("RewindStmt");
     return true;
   }
-  bool pre(const Save &x) {
+  bool Pre(const Save &x) {
     out("Save");
     return true;
   }
-  bool pre(const SaveStmt &x) {
+  bool Pre(const SaveStmt &x) {
     out("SaveStmt");
     return true;
   }
-  bool pre(const SavedEntity &x) {
+  bool Pre(const SavedEntity &x) {
     out("SavedEntity");
     return true;
   }
-  bool pre(const SectionSubscript &x) {
+  bool Pre(const SectionSubscript &x) {
     out("SectionSubscript");
     return true;
   }
-  bool pre(const SelectCaseStmt &x) {
+  bool Pre(const SelectCaseStmt &x) {
     out("SelectCaseStmt");
     return true;
   }
-  bool pre(const SelectRankCaseStmt &x) {
+  bool Pre(const SelectRankCaseStmt &x) {
     out("SelectRankCaseStmt");
     return true;
   }
-  bool pre(const SelectRankCaseStmt::Rank &x) {
+  bool Pre(const SelectRankCaseStmt::Rank &x) {
     out("SelectRankCaseStmt::Rank");
     return true;
   }
-  bool pre(const SelectRankConstruct &x) {
+  bool Pre(const SelectRankConstruct &x) {
     out("SelectRankConstruct");
     return true;
   }
-  bool pre(const SelectRankConstruct::RankCase &x) {
+  bool Pre(const SelectRankConstruct::RankCase &x) {
     out("SelectRankConstruct::RankCase");
     return true;
   }
-  bool pre(const SelectRankStmt &x) {
+  bool Pre(const SelectRankStmt &x) {
     out("SelectRankStmt");
     return true;
   }
-  bool pre(const SelectTypeConstruct &x) {
+  bool Pre(const SelectTypeConstruct &x) {
     out("SelectTypeConstruct");
     return true;
   }
-  bool pre(const SelectTypeConstruct::TypeCase &x) {
+  bool Pre(const SelectTypeConstruct::TypeCase &x) {
     out("SelectTypeConstruct::TypeCase");
     return true;
   }
-  bool pre(const SelectTypeStmt &x) {
+  bool Pre(const SelectTypeStmt &x) {
     out("SelectTypeStmt");
     return true;
   }
-  bool pre(const Selector &x) {
+  bool Pre(const Selector &x) {
     out("Selector");
     return true;
   }
-  bool pre(const SeparateModuleSubprogram &x) {
+  bool Pre(const SeparateModuleSubprogram &x) {
     out("SeparateModuleSubprogram");
     return true;
   }
-  bool pre(const SequenceStmt &x) {
+  bool Pre(const SequenceStmt &x) {
     out("SequenceStmt");
     return true;
   }
-  bool pre(const SignedComplexLiteralConstant &x) {
+  bool Pre(const SignedComplexLiteralConstant &x) {
     out("SignedComplexLiteralConstant");
     return true;
   }
-  bool pre(const SignedIntLiteralConstant &x) {
+  bool Pre(const SignedIntLiteralConstant &x) {
     out("SignedIntLiteralConstant");
     return true;
   }
-  bool pre(const SignedRealLiteralConstant &x) {
+  bool Pre(const SignedRealLiteralConstant &x) {
     out("SignedRealLiteralConstant");
     return true;
   }
-  bool pre(const SpecificationConstruct &x) {
+  bool Pre(const SpecificationConstruct &x) {
     out("SpecificationConstruct");
     return true;
   }
-  bool pre(const SpecificationExpr &x) {
+  bool Pre(const SpecificationExpr &x) {
     out("SpecificationExpr");
     return true;
   }
-  bool pre(const SpecificationPart &x) {
+  bool Pre(const SpecificationPart &x) {
     out("SpecificationPart");
     return true;
   }
-  bool pre(const Star &x) {
+  bool Pre(const Star &x) {
     out("Star");
     return true;
   }
-  bool pre(const StatOrErrmsg &x) {
+  bool Pre(const StatOrErrmsg &x) {
     out("StatOrErrmsg");
     return true;
   }
-  bool pre(const StatVariable &x) {
+  bool Pre(const StatVariable &x) {
     out("StatVariable");
     return true;
   }
-  bool pre(const StatusExpr &x) {
+  bool Pre(const StatusExpr &x) {
     out("StatusExpr");
     return true;
   }
-  bool pre(const StmtFunctionStmt &x) {
+  bool Pre(const StmtFunctionStmt &x) {
     out("StmtFunctionStmt");
     return true;
   }
-  bool pre(const StopCode &x) {
+  bool Pre(const StopCode &x) {
     out("StopCode");
     return true;
   }
-  bool pre(const StopStmt &x) {
+  bool Pre(const StopStmt &x) {
     out("StopStmt");
     return true;
   }
-  bool pre(const StructureComponent &x) {
+  bool Pre(const StructureComponent &x) {
     out("StructureComponent");
     return true;
   }
-  bool pre(const StructureConstructor &x) {
+  bool Pre(const StructureConstructor &x) {
     out("StructureConstructor");
     return true;
   }
-  bool pre(const StructureDef &x) {
+  bool Pre(const StructureDef &x) {
     out("StructureDef");
     return true;
   }
-  bool pre(const StructureDef::EndStructureStmt &x) {
+  bool Pre(const StructureDef::EndStructureStmt &x) {
     out("StructureDef::EndStructureStmt");
     return true;
   }
-  bool pre(const StructureField &x) {
+  bool Pre(const StructureField &x) {
     out("StructureField");
     return true;
   }
-  bool pre(const StructureStmt &x) {
+  bool Pre(const StructureStmt &x) {
     out("StructureStmt");
     return true;
   }
-  bool pre(const Submodule &x) {
+  bool Pre(const Submodule &x) {
     out("Submodule");
     return true;
   }
-  bool pre(const SubmoduleStmt &x) {
+  bool Pre(const SubmoduleStmt &x) {
     out("SubmoduleStmt");
     return true;
   }
-  bool pre(const SubroutineStmt &x) {
+  bool Pre(const SubroutineStmt &x) {
     out("SubroutineStmt");
     return true;
   }
-  bool pre(const SubroutineSubprogram &x) {
+  bool Pre(const SubroutineSubprogram &x) {
     out("SubroutineSubprogram");
     return true;
   }
-  bool pre(const SubscriptTriplet &x) {
+  bool Pre(const SubscriptTriplet &x) {
     out("SubscriptTriplet");
     return true;
   }
-  bool pre(const Substring &x) {
+  bool Pre(const Substring &x) {
     out("Substring");
     return true;
   }
-  bool pre(const SubstringRange &x) {
+  bool Pre(const SubstringRange &x) {
     out("SubstringRange");
     return true;
   }
-  bool pre(const Suffix &x) {
+  bool Pre(const Suffix &x) {
     out("Suffix");
     return true;
   }
-  bool pre(const SyncAllStmt &x) {
+  bool Pre(const SyncAllStmt &x) {
     out("SyncAllStmt");
     return true;
   }
-  bool pre(const SyncImagesStmt &x) {
+  bool Pre(const SyncImagesStmt &x) {
     out("SyncImagesStmt");
     return true;
   }
-  bool pre(const SyncImagesStmt::ImageSet &x) {
+  bool Pre(const SyncImagesStmt::ImageSet &x) {
     out("SyncImagesStmt::ImageSet");
     return true;
   }
-  bool pre(const SyncMemoryStmt &x) {
+  bool Pre(const SyncMemoryStmt &x) {
     out("SyncMemoryStmt");
     return true;
   }
-  bool pre(const SyncTeamStmt &x) {
+  bool Pre(const SyncTeamStmt &x) {
     out("SyncTeamStmt");
     return true;
   }
-  bool pre(const Target &x) {
+  bool Pre(const Target &x) {
     out("Target");
     return true;
   }
-  bool pre(const TargetStmt &x) {
+  bool Pre(const TargetStmt &x) {
     out("TargetStmt");
     return true;
   }
-  bool pre(const TypeAttrSpec &x) {
+  bool Pre(const TypeAttrSpec &x) {
     out("TypeAttrSpec");
     return true;
   }
-  bool pre(const TypeAttrSpec::BindC &x) {
+  bool Pre(const TypeAttrSpec::BindC &x) {
     out("TypeAttrSpec::BindC");
     return true;
   }
-  bool pre(const TypeAttrSpec::Extends &x) {
+  bool Pre(const TypeAttrSpec::Extends &x) {
     out("TypeAttrSpec::Extends");
     return true;
   }
-  bool pre(const TypeBoundGenericStmt &x) {
+  bool Pre(const TypeBoundGenericStmt &x) {
     out("TypeBoundGenericStmt");
     return true;
   }
-  bool pre(const TypeBoundProcBinding &x) {
+  bool Pre(const TypeBoundProcBinding &x) {
     out("TypeBoundProcBinding");
     return true;
   }
-  bool pre(const TypeBoundProcDecl &x) {
+  bool Pre(const TypeBoundProcDecl &x) {
     out("TypeBoundProcDecl");
     return true;
   }
-  bool pre(const TypeBoundProcedurePart &x) {
+  bool Pre(const TypeBoundProcedurePart &x) {
     out("TypeBoundProcedurePart");
     return true;
   }
-  bool pre(const TypeBoundProcedureStmt &x) {
+  bool Pre(const TypeBoundProcedureStmt &x) {
     out("TypeBoundProcedureStmt");
     return true;
   }
-  bool pre(const TypeBoundProcedureStmt::WithInterface &x) {
+  bool Pre(const TypeBoundProcedureStmt::WithInterface &x) {
     out("TypeBoundProcedureStmt::WithInterface");
     return true;
   }
-  bool pre(const TypeBoundProcedureStmt::WithoutInterface &x) {
+  bool Pre(const TypeBoundProcedureStmt::WithoutInterface &x) {
     out("TypeBoundProcedureStmt::WithoutInterface");
     return true;
   }
-  bool pre(const TypeDeclarationStmt &x) {
+  bool Pre(const TypeDeclarationStmt &x) {
     out("TypeDeclarationStmt");
     return true;
   }
-  bool pre(const TypeGuardStmt &x) {
+  bool Pre(const TypeGuardStmt &x) {
     out("TypeGuardStmt");
     return true;
   }
-  bool pre(const TypeGuardStmt::Guard &x) {
+  bool Pre(const TypeGuardStmt::Guard &x) {
     out("TypeGuardStmt::Guard");
     return true;
   }
-  bool pre(const TypeParamDecl &x) {
+  bool Pre(const TypeParamDecl &x) {
     out("TypeParamDecl");
     return true;
   }
-  bool pre(const TypeParamDefStmt &x) {
+  bool Pre(const TypeParamDefStmt &x) {
     out("TypeParamDefStmt");
     return true;
   }
-  bool pre(const TypeParamInquiry &x) {
+  bool Pre(const TypeParamInquiry &x) {
     out("TypeParamInquiry");
     return true;
   }
-  bool pre(const TypeParamSpec &x) {
+  bool Pre(const TypeParamSpec &x) {
     out("TypeParamSpec");
     return true;
   }
-  bool pre(const TypeParamValue &x) {
+  bool Pre(const TypeParamValue &x) {
     out("TypeParamValue");
     return true;
   }
-  bool pre(const TypeParamValue::Deferred &x) {
+  bool Pre(const TypeParamValue::Deferred &x) {
     out("TypeParamValue::Deferred");
     return true;
   }
-  bool pre(const TypeSpec &x) {
+  bool Pre(const TypeSpec &x) {
     out("TypeSpec");
     return true;
   }
-  bool pre(const Union &x) {
+  bool Pre(const Union &x) {
     out("Union");
     return true;
   }
-  bool pre(const Union::EndUnionStmt &x) {
+  bool Pre(const Union::EndUnionStmt &x) {
     out("Union::EndUnionStmt");
     return true;
   }
-  bool pre(const Union::UnionStmt &x) {
+  bool Pre(const Union::UnionStmt &x) {
     out("Union::UnionStmt");
     return true;
   }
-  bool pre(const UnlockStmt &x) {
+  bool Pre(const UnlockStmt &x) {
     out("UnlockStmt");
     return true;
   }
-  bool pre(const UseStmt &x) {
+  bool Pre(const UseStmt &x) {
     out("UseStmt");
     return true;
   }
-  bool pre(const Value &x) {
+  bool Pre(const Value &x) {
     out("Value");
     return true;
   }
-  bool pre(const ValueStmt &x) {
+  bool Pre(const ValueStmt &x) {
     out("ValueStmt");
     return true;
   }
-  bool pre(const Variable &x) {
+  bool Pre(const Variable &x) {
     out("Variable");
     return true;
   }
-  bool pre(const Volatile &x) {
+  bool Pre(const Volatile &x) {
     out("Volatile");
     return true;
   }
-  bool pre(const VolatileStmt &x) {
+  bool Pre(const VolatileStmt &x) {
     out("VolatileStmt");
     return true;
   }
-  bool pre(const WaitSpec &x) {
+  bool Pre(const WaitSpec &x) {
     out("WaitSpec");
     return true;
   }
-  bool pre(const WaitStmt &x) {
+  bool Pre(const WaitStmt &x) {
     out("WaitStmt");
     return true;
   }
-  bool pre(const WhereBodyConstruct &x) {
+  bool Pre(const WhereBodyConstruct &x) {
     out("WhereBodyConstruct");
     return true;
   }
-  bool pre(const WhereConstruct &x) {
+  bool Pre(const WhereConstruct &x) {
     out("WhereConstruct");
     return true;
   }
-  bool pre(const WhereConstruct::Elsewhere &x) {
+  bool Pre(const WhereConstruct::Elsewhere &x) {
     out("WhereConstruct::Elsewhere");
     return true;
   }
-  bool pre(const WhereConstruct::MaskedElsewhere &x) {
+  bool Pre(const WhereConstruct::MaskedElsewhere &x) {
     out("WhereConstruct::MaskedElsewhere");
     return true;
   }
-  bool pre(const WhereConstructStmt &x) {
+  bool Pre(const WhereConstructStmt &x) {
     out("WhereConstructStmt");
     return true;
   }
-  bool pre(const WhereStmt &x) {
+  bool Pre(const WhereStmt &x) {
     out("WhereStmt");
     return true;
   }
-  bool pre(const WriteStmt &x) {
+  bool Pre(const WriteStmt &x) {
     out("WriteStmt");
     return true;
   }
 
   template<typename T>
-  bool pre(const LoopBounds<T> &x) {
+  bool Pre(const LoopBounds<T> &x) {
     out("LoopBounds");
     return true;
   }
   template<typename T>
-  bool pre(const Statement<T> &x) {
+  bool Pre(const Statement<T> &x) {
     out("Statement");
     return true;
   }
-  bool pre(const int &x) {
+  bool Pre(const int &x) {
     out(std::string{"int: "} + std::to_string(x));
     return true;
   }
-  bool pre(const std::uint64_t &x) {
+  bool Pre(const std::uint64_t &x) {
     out(std::string{"std::uint64_t: "} + std::to_string(x));
     return true;
   }
-  bool pre(const std::string &x) {
+  bool Pre(const std::string &x) {
     out(std::string{"std::string: "} + x);
     return true;
   }
-  bool pre(const std::int64_t &x) {
+  bool Pre(const std::int64_t &x) {
     out(std::string{"std::int64_t: "} + std::to_string(x));
     return true;
   }
-  bool pre(const char &x) {
+  bool Pre(const char &x) {
     out(std::string{"char: "} + x);
     return true;
   }
-  bool pre(const Sign &x) {
+  bool Pre(const Sign &x) {
     out(std::string{"Sign: "} + (x == Sign::Positive ? "+" : "-"));
     return true;
   }
 
   template<typename T>
-  bool pre(const T &x) {
+  bool Pre(const T &x) {
     out("generic");
     return true;
   }
 
   template<typename T>
-  void post(const T &) {
+  void Post(const T &) {
     --indent_;
   }
 };
@@ -2027,6 +2027,6 @@ int main(int argc, char *const argv[]) {
   }
 
   Visitor visitor;
-  visit(*result, visitor);
+  Walk(*result, visitor);
   return EXIT_SUCCESS;
 }