Fix up visitor approach.

The existing code used a catch-all `visit()` method, and then relied on overloading to find the right version (allowing fallback to a `visit()` method taking a base-class parameter).
This approach works, but has some big down-sides:

- When browsing the code, you have a bunch of identically-named methods, and it can be hard to find the one you want.

- It is impossible to use inheritance to implement fallback for `visit()` methods, because *any* method in the derived class with that name hides *all* methods with the same name in a base class

This change makes the `visit()` methods use the name of the corresponding syntax class, and then has visitors inherit the fallback methods they need from the base visitor template class.

3 files changed, 226 insertions, 130 deletions

diff --git a/source/slang/check.cpp b/source/slang/check.cpp
index 2d61c60a4..7c67473be 100644
--- a/source/slang/check.cpp
+++ b/source/slang/check.cpp
@@ -1072,7 +1072,7 @@ namespace Slang
             EnsureDecl(decl, DeclCheckState::Checked);
         }
 
-        void visit(GenericDecl* genericDecl)
+        void visitGenericDecl(GenericDecl* genericDecl)
         {
             // check the parameters
             for (auto m : genericDecl->Members)
@@ -1097,12 +1097,12 @@ namespace Slang
             checkDecl(genericDecl->inner);
         }
 
-        void visit(InterfaceDecl* /*decl*/)
+        void visitInterfaceDecl(InterfaceDecl* /*decl*/)
         {
             // TODO: do some actual checking of members here
         }
 
-        void visit(InheritanceDecl* inheritanceDecl)
+        void visitInheritanceDecl(InheritanceDecl* inheritanceDecl)
         {
             // check the type being inherited from
             auto base = inheritanceDecl->base;
@@ -1144,27 +1144,27 @@ namespace Slang
             return constIntVal;
         }
 
-        void visit(ModifierDecl*)
+        void visitModifierDecl(ModifierDecl*)
         {
             // These are only used in the stdlib, so no checking is needed
         }
 
-        void visit(GenericTypeParamDecl*)
+        void visitGenericTypeParamDecl(GenericTypeParamDecl*)
         {
             // These are only used in the stdlib, so no checking is needed for now
         }
 
-        void visit(GenericValueParamDecl*)
+        void visitGenericValueParamDecl(GenericValueParamDecl*)
         {
             // These are only used in the stdlib, so no checking is needed for now
         }
 
-        void visit(GenericTypeConstraintDecl*)
+        void visitGenericTypeConstraintDecl(GenericTypeConstraintDecl*)
         {
             // These are only used in the stdlib, so no checking is needed for now
         }
 
-        void visit(Modifier*)
+        void visitModifier(Modifier*)
         {
             // Do nothing with modifiers for now
         }
@@ -1270,7 +1270,7 @@ namespace Slang
             decl->modifiers.first = resultModifiers;
         }
 
-        void visit(ProgramSyntaxNode* programNode)
+        void visitProgramSyntaxNode(ProgramSyntaxNode* programNode)
         {
             // Try to register all the builtin decls
             for (auto decl : programNode->Members)
@@ -1347,7 +1347,7 @@ namespace Slang
             }
         }
 
-		void visit(ClassSyntaxNode * classNode)
+		void visitClassSyntaxNode(ClassSyntaxNode * classNode)
 		{
 			if (classNode->IsChecked(DeclCheckState::Checked))
 				return;
@@ -1360,7 +1360,7 @@ namespace Slang
 			}
 		}
 
-        void visit(StructField* field)
+        void visitStructField(StructField* field)
         {
             // TODO: bottleneck through general-case variable checking
 
@@ -1368,7 +1368,7 @@ namespace Slang
             field->SetCheckState(DeclCheckState::Checked);
         }
 
-        void visit(StructSyntaxNode * structNode)
+        void visitStructSyntaxNode(StructSyntaxNode * structNode)
         {
             if (structNode->IsChecked(DeclCheckState::Checked))
                 return;
@@ -1380,7 +1380,7 @@ namespace Slang
             }
         }
 
-        void visit(DeclGroup* declGroup)
+        void visitDeclGroup(DeclGroup* declGroup)
         {
             for (auto decl : declGroup->decls)
             {
@@ -1388,7 +1388,7 @@ namespace Slang
             }
         }
 
-        void visit(TypeDefDecl* decl)
+        void visitTypeDefDecl(TypeDefDecl* decl)
         {
             if (decl->IsChecked(DeclCheckState::Checked)) return;
 
@@ -1403,7 +1403,7 @@ namespace Slang
             StmtVisitor::dispatch(stmt);
         }
 
-        void visit(FunctionSyntaxNode *functionNode)
+        void visitFunctionSyntaxNode(FunctionSyntaxNode *functionNode)
         {
             if (functionNode->IsChecked(DeclCheckState::Checked))
                 return;
@@ -1528,12 +1528,12 @@ namespace Slang
             }
         }
 
-        void visit(ScopeDecl*)
+        void visitScopeDecl(ScopeDecl*)
         {
             // Nothing to do
         }
 
-        void visit(ParameterSyntaxNode* para)
+        void visitParameterSyntaxNode(ParameterSyntaxNode* para)
         {
             // TODO: This needs to bottleneck through the common variable checks
 
@@ -1567,7 +1567,7 @@ namespace Slang
             ValidateFunctionRedeclaration(functionNode);
         }
 
-        void visit(VarDeclrStatementSyntaxNode* stmt)
+        void visitVarDeclrStatementSyntaxNode(VarDeclrStatementSyntaxNode* stmt)
         {
             // We directly dispatch here instead of using `EnsureDecl()` for two
             // reasons:
@@ -1581,12 +1581,12 @@ namespace Slang
             DeclVisitor::dispatch(stmt->decl);
         }
 
-        void visit(BlockStmt* stmt)
+        void visitBlockStmt(BlockStmt* stmt)
         {
             checkStmt(stmt->body);
         }
 
-        void visit(SeqStmt* stmt)
+        void visitSeqStmt(SeqStmt* stmt)
         {
             for(auto ss : stmt->stmts)
             {
@@ -1608,7 +1608,7 @@ namespace Slang
             return nullptr;
         }
 
-        void visit(BreakStatementSyntaxNode *stmt)
+        void visitBreakStatementSyntaxNode(BreakStatementSyntaxNode *stmt)
         {
             auto outer = FindOuterStmt<BreakableStmt>();
             if (!outer)
@@ -1617,7 +1617,7 @@ namespace Slang
             }
             stmt->parentStmt = outer;
         }
-        void visit(ContinueStatementSyntaxNode *stmt)
+        void visitContinueStatementSyntaxNode(ContinueStatementSyntaxNode *stmt)
         {
             auto outer = FindOuterStmt<LoopStmt>();
             if (!outer)
@@ -1645,7 +1645,7 @@ namespace Slang
             return e;
         }
 
-        void visit(DoWhileStatementSyntaxNode *stmt)
+        void visitDoWhileStatementSyntaxNode(DoWhileStatementSyntaxNode *stmt)
         {
             PushOuterStmt(stmt);
             stmt->Predicate = checkPredicateExpr(stmt->Predicate);
@@ -1653,7 +1653,7 @@ namespace Slang
 
             PopOuterStmt(stmt);
         }
-        void visit(ForStatementSyntaxNode *stmt)
+        void visitForStatementSyntaxNode(ForStatementSyntaxNode *stmt)
         {
             PushOuterStmt(stmt);
             checkStmt(stmt->InitialStatement);
@@ -1669,7 +1669,7 @@ namespace Slang
 
             PopOuterStmt(stmt);
         }
-        void visit(SwitchStmt* stmt)
+        void visitSwitchStmt(SwitchStmt* stmt)
         {
             PushOuterStmt(stmt);
             // TODO(tfoley): need to coerce condition to an integral type...
@@ -1682,7 +1682,7 @@ namespace Slang
 
             PopOuterStmt(stmt);
         }
-        void visit(CaseStmt* stmt)
+        void visitCaseStmt(CaseStmt* stmt)
         {
             // TODO(tfoley): Need to coerce to type being switch on,
             // and ensure that value is a compile-time constant
@@ -1702,7 +1702,7 @@ namespace Slang
             stmt->expr = expr;
             stmt->parentStmt = switchStmt;
         }
-        void visit(DefaultStmt* stmt)
+        void visitDefaultStmt(DefaultStmt* stmt)
         {
             auto switchStmt = FindOuterStmt<SwitchStmt>();
             if (!switchStmt)
@@ -1711,30 +1711,30 @@ namespace Slang
             }
             stmt->parentStmt = switchStmt;
         }
-        void visit(IfStatementSyntaxNode *stmt)
+        void visitIfStatementSyntaxNode(IfStatementSyntaxNode *stmt)
         {
             stmt->Predicate = checkPredicateExpr(stmt->Predicate);
             checkStmt(stmt->PositiveStatement);
             checkStmt(stmt->NegativeStatement);
         }
 
-        void visit(UnparsedStmt*)
+        void visitUnparsedStmt(UnparsedStmt*)
         {
             // Nothing to do
         }
 
 
-        void visit(EmptyStatementSyntaxNode*)
+        void visitEmptyStatementSyntaxNode(EmptyStatementSyntaxNode*)
         {
             // Nothing to do
         }
 
-        void visit(DiscardStatementSyntaxNode*)
+        void visitDiscardStatementSyntaxNode(DiscardStatementSyntaxNode*)
         {
             // Nothing to do
         }
 
-        void visit(ReturnStatementSyntaxNode *stmt)
+        void visitReturnStatementSyntaxNode(ReturnStatementSyntaxNode *stmt)
         {
             if (!stmt->Expression)
             {
@@ -1837,7 +1837,7 @@ namespace Slang
             }
         }
 
-        void visit(Variable* varDecl)
+        void visitVariable(Variable* varDecl)
         {
             TypeExp typeExp = CheckUsableType(varDecl->Type);
 #if 0
@@ -1887,19 +1887,19 @@ namespace Slang
             varDecl->SetCheckState(DeclCheckState::Checked);
         }
 
-        void visit(WhileStatementSyntaxNode *stmt)
+        void visitWhileStatementSyntaxNode(WhileStatementSyntaxNode *stmt)
         {
             PushOuterStmt(stmt);
             stmt->Predicate = checkPredicateExpr(stmt->Predicate);
             checkStmt(stmt->Statement);
             PopOuterStmt(stmt);
         }
-        void visit(ExpressionStatementSyntaxNode *stmt)
+        void visitExpressionStatementSyntaxNode(ExpressionStatementSyntaxNode *stmt)
         {
             stmt->Expression = CheckExpr(stmt->Expression);
         }
 
-        RefPtr<ExpressionSyntaxNode> visit(ConstantExpressionSyntaxNode *expr)
+        RefPtr<ExpressionSyntaxNode> visitConstantExpressionSyntaxNode(ConstantExpressionSyntaxNode *expr)
         {
             // The expression might already have a type, determined by its suffix
             if(expr->Type.type)
@@ -2216,7 +2216,7 @@ namespace Slang
             return DeclRefType::Create(declRef)->As<VectorExpressionType>();
         }
 
-        RefPtr<ExpressionSyntaxNode> visit(IndexExpressionSyntaxNode* subscriptExpr)
+        RefPtr<ExpressionSyntaxNode> visitIndexExpressionSyntaxNode(IndexExpressionSyntaxNode* subscriptExpr)
         {
             auto baseExpr = subscriptExpr->BaseExpression;
             baseExpr = CheckExpr(baseExpr);
@@ -2421,7 +2421,7 @@ namespace Slang
 
         //
 
-        RefPtr<ExpressionSyntaxNode> visit(AssignExpr* expr)
+        RefPtr<ExpressionSyntaxNode> visitAssignExpr(AssignExpr* expr)
         {
             expr->left = CheckExpr(expr->left);
 
@@ -2440,7 +2440,7 @@ namespace Slang
 
         //
 
-        void visit(ExtensionDecl* decl)
+        void visitExtensionDecl(ExtensionDecl* decl)
         {
             if (decl->IsChecked(DeclCheckState::Checked)) return;
 
@@ -2483,7 +2483,7 @@ namespace Slang
             decl->SetCheckState(DeclCheckState::Checked);
         }
 
-        void visit(ConstructorDecl* decl)
+        void visitConstructorDecl(ConstructorDecl* decl)
         {
             if (decl->IsChecked(DeclCheckState::Checked)) return;
             decl->SetCheckState(DeclCheckState::CheckingHeader);
@@ -2499,7 +2499,7 @@ namespace Slang
         }
 
 
-        void visit(SubscriptDecl* decl)
+        void visitSubscriptDecl(SubscriptDecl* decl)
         {
             if (decl->IsChecked(DeclCheckState::Checked)) return;
             decl->SetCheckState(DeclCheckState::CheckingHeader);
@@ -2516,7 +2516,7 @@ namespace Slang
             decl->SetCheckState(DeclCheckState::Checked);
         }
 
-        void visit(AccessorDecl* decl)
+        void visitAccessorDecl(AccessorDecl* decl)
         {
             // TODO: check the body!
 
@@ -4369,7 +4369,7 @@ namespace Slang
             }
         }
 
-        RefPtr<ExpressionSyntaxNode> visit(GenericAppExpr * genericAppExpr)
+        RefPtr<ExpressionSyntaxNode> visitGenericAppExpr(GenericAppExpr * genericAppExpr)
         {
             // We are applying a generic to arguments, but there might be multiple generic
             // declarations with the same name, so this becomes a specialized case of
@@ -4520,7 +4520,7 @@ namespace Slang
 #endif
         }
 
-        RefPtr<ExpressionSyntaxNode> visit(SharedTypeExpr* expr)
+        RefPtr<ExpressionSyntaxNode> visitSharedTypeExpr(SharedTypeExpr* expr)
         {
             if (!expr->Type.Ptr())
             {
@@ -4578,7 +4578,7 @@ namespace Slang
             return rs;
         }
 
-        RefPtr<ExpressionSyntaxNode> visit(InvokeExpressionSyntaxNode *expr)
+        RefPtr<ExpressionSyntaxNode> visitInvokeExpressionSyntaxNode(InvokeExpressionSyntaxNode *expr)
         {
             // check the base expression first
             expr->FunctionExpr = CheckExpr(expr->FunctionExpr);
@@ -4593,7 +4593,7 @@ namespace Slang
         }
 
 
-        RefPtr<ExpressionSyntaxNode> visit(VarExpressionSyntaxNode *expr)
+        RefPtr<ExpressionSyntaxNode> visitVarExpressionSyntaxNode(VarExpressionSyntaxNode *expr)
         {
             // If we've already resolved this expression, don't try again.
             if (expr->declRef)
@@ -4615,7 +4615,7 @@ namespace Slang
             return expr;
         }
 
-        RefPtr<ExpressionSyntaxNode> visit(TypeCastExpressionSyntaxNode * expr)
+        RefPtr<ExpressionSyntaxNode> visitTypeCastExpressionSyntaxNode(TypeCastExpressionSyntaxNode * expr)
         {
             expr->Expression = CheckTerm(expr->Expression);
             auto targetType = CheckProperType(expr->TargetType);
@@ -4694,19 +4694,19 @@ namespace Slang
         // deal with this cases here, even if they are no-ops.
         //
 
-        RefPtr<ExpressionSyntaxNode> visit(DerefExpr* expr)
+        RefPtr<ExpressionSyntaxNode> visitDerefExpr(DerefExpr* expr)
         {
             assert(!"unexpected");
             return expr;
         }
 
-        RefPtr<ExpressionSyntaxNode> visit(SwizzleExpr* expr)
+        RefPtr<ExpressionSyntaxNode> visitSwizzleExpr(SwizzleExpr* expr)
         {
             assert(!"unexpected");
             return expr;
         }
 
-        RefPtr<ExpressionSyntaxNode> visit(OverloadedExpr* expr)
+        RefPtr<ExpressionSyntaxNode> visitOverloadedExpr(OverloadedExpr* expr)
         {
             assert(!"unexpected");
             return expr;
@@ -4850,7 +4850,7 @@ namespace Slang
         }
 
 
-        RefPtr<ExpressionSyntaxNode> visit(MemberExpressionSyntaxNode * expr)
+        RefPtr<ExpressionSyntaxNode> visitMemberExpressionSyntaxNode(MemberExpressionSyntaxNode * expr)
         {
             expr->BaseExpression = CheckExpr(expr->BaseExpression);
 
@@ -4949,7 +4949,7 @@ namespace Slang
 
         //
 
-        RefPtr<ExpressionSyntaxNode> visit(InitializerListExpr* expr)
+        RefPtr<ExpressionSyntaxNode> visitInitializerListExpr(InitializerListExpr* expr)
         {
             // When faced with an initializer list, we first just check the sub-expressions blindly.
             // Actually making them conform to a desired type will wait for when we know the desired
@@ -4995,12 +4995,12 @@ namespace Slang
             }
         }
 
-        void visit(EmptyDecl* /*decl*/)
+        void visitEmptyDecl(EmptyDecl* /*decl*/)
         {
             // nothing to do
         }
 
-        void visit(ImportDecl* decl)
+        void visitImportDecl(ImportDecl* decl)
         {
             if(decl->IsChecked(DeclCheckState::Checked))
                 return;
diff --git a/source/slang/lower.cpp b/source/slang/lower.cpp
index f9bf97107..8bc9619f3 100644
--- a/source/slang/lower.cpp
+++ b/source/slang/lower.cpp
@@ -76,6 +76,7 @@ struct StructuralTransformVisitorBase
     }
 };
 
+#if 0
 template<typename V>
 struct StructuralTransformStmtVisitor
     : StructuralTransformVisitorBase<V>
@@ -107,6 +108,7 @@ struct StructuralTransformStmtVisitor
 #include "object-meta-end.h"
 
 };
+#endif
 
 template<typename V>
 RefPtr<StatementSyntaxNode> structuralTransform(
@@ -130,7 +132,7 @@ struct StructuralTransformExprVisitor
 
 
 #define SYNTAX_CLASS(NAME, BASE, ...)                   \
-    RefPtr<ExpressionSyntaxNode> visit(NAME* obj) {     \
+    RefPtr<ExpressionSyntaxNode> visit##NAME(NAME* obj) {     \
         RefPtr<NAME> result = new NAME(*obj);           \
         transformFields(result, obj);                   \
         return result;                                  \
@@ -216,8 +218,7 @@ struct LoweringVisitor
     : ExprVisitor<LoweringVisitor, RefPtr<ExpressionSyntaxNode>>
     , StmtVisitor<LoweringVisitor, void>
     , DeclVisitor<LoweringVisitor, RefPtr<Decl>>
-    , TypeVisitor<LoweringVisitor, RefPtr<ExpressionType>>
-    , ValVisitor<LoweringVisitor, RefPtr<Val>>
+    , ValVisitor<LoweringVisitor, RefPtr<Val>, RefPtr<ExpressionType>>
 {
     //
     SharedLoweringContext*      shared;
@@ -247,12 +248,12 @@ struct LoweringVisitor
         return ValVisitor::dispatch(val);
     }
 
-    RefPtr<Val> visit(GenericParamIntVal* val)
+    RefPtr<Val> visitGenericParamIntVal(GenericParamIntVal* val)
     {
         return new GenericParamIntVal(translateDeclRef(DeclRef<Decl>(val->declRef)).As<VarDeclBase>());
     }
 
-    RefPtr<Val> visit(ConstantIntVal* val)
+    RefPtr<Val> visitConstantIntVal(ConstantIntVal* val)
     {
         return val;
     }
@@ -276,40 +277,40 @@ struct LoweringVisitor
         return result;
     }
 
-    RefPtr<ExpressionType> visit(ErrorType* type)
+    RefPtr<ExpressionType> visitErrorType(ErrorType* type)
     {
         return type;
     }
 
-    RefPtr<ExpressionType> visit(OverloadGroupType* type)
+    RefPtr<ExpressionType> visitOverloadGroupType(OverloadGroupType* type)
     {
         return type;
     }
 
-    RefPtr<ExpressionType> visit(InitializerListType* type)
+    RefPtr<ExpressionType> visitInitializerListType(InitializerListType* type)
     {
         return type;
     }
 
-    RefPtr<ExpressionType> visit(GenericDeclRefType* type)
+    RefPtr<ExpressionType> visitGenericDeclRefType(GenericDeclRefType* type)
     {
         return new GenericDeclRefType(translateDeclRef(DeclRef<Decl>(type->declRef)).As<GenericDecl>());
     }
 
-    RefPtr<ExpressionType> visit(FuncType* type)
+    RefPtr<ExpressionType> visitFuncType(FuncType* type)
     {
         RefPtr<FuncType> loweredType = new FuncType();
         loweredType->declRef = translateDeclRef(DeclRef<Decl>(type->declRef)).As<CallableDecl>();
         return loweredType;
     }
 
-    RefPtr<ExpressionType> visit(DeclRefType* type)
+    RefPtr<ExpressionType> visitDeclRefType(DeclRefType* type)
     {
         auto loweredDeclRef = translateDeclRef(type->declRef);
         return DeclRefType::Create(loweredDeclRef);
     }
 
-    RefPtr<ExpressionType> visit(NamedExpressionType* type)
+    RefPtr<ExpressionType> visitNamedExpressionType(NamedExpressionType* type)
     {
         if (shared->target == CodeGenTarget::GLSL)
         {
@@ -320,12 +321,12 @@ struct LoweringVisitor
         return new NamedExpressionType(translateDeclRef(DeclRef<Decl>(type->declRef)).As<TypeDefDecl>());
     }
 
-    RefPtr<ExpressionType> visit(TypeType* type)
+    RefPtr<ExpressionType> visitTypeType(TypeType* type)
     {
         return new TypeType(lowerType(type->type));
     }
 
-    RefPtr<ExpressionType> visit(ArrayExpressionType* type)
+    RefPtr<ExpressionType> visitArrayExpressionType(ArrayExpressionType* type)
     {
         RefPtr<ArrayExpressionType> loweredType = new ArrayExpressionType();
         loweredType->BaseType = lowerType(type->BaseType);
@@ -350,7 +351,7 @@ struct LoweringVisitor
     }
 
     // catch-all
-    RefPtr<ExpressionSyntaxNode> visit(
+    RefPtr<ExpressionSyntaxNode> visitExpressionSyntaxNode(
         ExpressionSyntaxNode* expr)
     {
         return structuralTransform(expr, this);
@@ -404,7 +405,7 @@ struct LoweringVisitor
         return result;
     }
 
-    RefPtr<ExpressionSyntaxNode> visit(
+    RefPtr<ExpressionSyntaxNode> visitVarExpressionSyntaxNode(
         VarExpressionSyntaxNode* expr)
     {
         // If the expression didn't get resolved, we can leave it as-is
@@ -428,7 +429,7 @@ struct LoweringVisitor
         return loweredExpr;
     }
 
-    RefPtr<ExpressionSyntaxNode> visit(
+    RefPtr<ExpressionSyntaxNode> visitMemberExpressionSyntaxNode(
         MemberExpressionSyntaxNode* expr)
     {
         auto loweredBase = lowerExpr(expr->BaseExpression);
@@ -521,7 +522,7 @@ struct LoweringVisitor
         StmtVisitor::dispatch(stmt);
     }
 
-    RefPtr<ScopeDecl> visit(ScopeDecl* decl)
+    RefPtr<ScopeDecl> visitScopeDecl(ScopeDecl* decl)
     {
         RefPtr<ScopeDecl> loweredDecl = new ScopeDecl();
         lowerDeclCommon(loweredDecl, decl);
@@ -594,7 +595,7 @@ struct LoweringVisitor
         addStmt(stmt);
     }
 
-    void visit(BlockStmt* stmt)
+    void visitBlockStmt(BlockStmt* stmt)
     {
         RefPtr<BlockStmt> loweredStmt = new BlockStmt();
         lowerScopeStmtFields(loweredStmt, stmt);
@@ -606,7 +607,7 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    void visit(SeqStmt* stmt)
+    void visitSeqStmt(SeqStmt* stmt)
     {
         for( auto ss : stmt->stmts )
         {
@@ -614,12 +615,12 @@ struct LoweringVisitor
         }
     }
 
-    void visit(ExpressionStatementSyntaxNode* stmt)
+    void visitExpressionStatementSyntaxNode(ExpressionStatementSyntaxNode* stmt)
     {
         addExprStmt(lowerExpr(stmt->Expression));
     }
 
-    void visit(VarDeclrStatementSyntaxNode* stmt)
+    void visitVarDeclrStatementSyntaxNode(VarDeclrStatementSyntaxNode* stmt)
     {
         DeclVisitor::dispatch(stmt->decl);
     }
@@ -651,42 +652,42 @@ struct LoweringVisitor
         loweredStmt->parentStmt = translateStmtRef(originalStmt->parentStmt);
     }
 
-    void visit(ContinueStatementSyntaxNode* stmt)
+    void visitContinueStatementSyntaxNode(ContinueStatementSyntaxNode* stmt)
     {
         RefPtr<ContinueStatementSyntaxNode> loweredStmt = new ContinueStatementSyntaxNode();
         lowerChildStmtFields(loweredStmt, stmt);
         addStmt(loweredStmt);
     }
 
-    void visit(BreakStatementSyntaxNode* stmt)
+    void visitBreakStatementSyntaxNode(BreakStatementSyntaxNode* stmt)
     {
         RefPtr<BreakStatementSyntaxNode> loweredStmt = new BreakStatementSyntaxNode();
         lowerChildStmtFields(loweredStmt, stmt);
         addStmt(loweredStmt);
     }
 
-    void visit(DefaultStmt* stmt)
+    void visitDefaultStmt(DefaultStmt* stmt)
     {
         RefPtr<DefaultStmt> loweredStmt = new DefaultStmt();
         lowerChildStmtFields(loweredStmt, stmt);
         addStmt(loweredStmt);
     }
 
-    void visit(DiscardStatementSyntaxNode* stmt)
+    void visitDiscardStatementSyntaxNode(DiscardStatementSyntaxNode* stmt)
     {
         RefPtr<DiscardStatementSyntaxNode> loweredStmt = new DiscardStatementSyntaxNode();
         lowerStmtFields(loweredStmt, stmt);
         addStmt(loweredStmt);
     }
 
-    void visit(EmptyStatementSyntaxNode* stmt)
+    void visitEmptyStatementSyntaxNode(EmptyStatementSyntaxNode* stmt)
     {
         RefPtr<EmptyStatementSyntaxNode> loweredStmt = new EmptyStatementSyntaxNode();
         lowerStmtFields(loweredStmt, stmt);
         addStmt(loweredStmt);
     }
 
-    void visit(UnparsedStmt* stmt)
+    void visitUnparsedStmt(UnparsedStmt* stmt)
     {
         RefPtr<UnparsedStmt> loweredStmt = new UnparsedStmt();
         lowerStmtFields(loweredStmt, stmt);
@@ -696,7 +697,7 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    void visit(CaseStmt* stmt)
+    void visitCaseStmt(CaseStmt* stmt)
     {
         RefPtr<CaseStmt> loweredStmt = new CaseStmt();
         lowerChildStmtFields(loweredStmt, stmt);
@@ -706,7 +707,7 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    void visit(IfStatementSyntaxNode* stmt)
+    void visitIfStatementSyntaxNode(IfStatementSyntaxNode* stmt)
     {
         RefPtr<IfStatementSyntaxNode> loweredStmt = new IfStatementSyntaxNode();
         lowerStmtFields(loweredStmt, stmt);
@@ -718,7 +719,7 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    void visit(SwitchStmt* stmt)
+    void visitSwitchStmt(SwitchStmt* stmt)
     {
         RefPtr<SwitchStmt> loweredStmt = new SwitchStmt();
         lowerScopeStmtFields(loweredStmt, stmt);
@@ -732,7 +733,7 @@ struct LoweringVisitor
     }
 
 
-    void visit(ForStatementSyntaxNode* stmt)
+    void visitForStatementSyntaxNode(ForStatementSyntaxNode* stmt)
     {
         RefPtr<ForStatementSyntaxNode> loweredStmt = new ForStatementSyntaxNode();
         lowerScopeStmtFields(loweredStmt, stmt);
@@ -747,7 +748,7 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    void visit(WhileStatementSyntaxNode* stmt)
+    void visitWhileStatementSyntaxNode(WhileStatementSyntaxNode* stmt)
     {
         RefPtr<WhileStatementSyntaxNode> loweredStmt = new WhileStatementSyntaxNode();
         lowerScopeStmtFields(loweredStmt, stmt);
@@ -760,7 +761,7 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    void visit(DoWhileStatementSyntaxNode* stmt)
+    void visitDoWhileStatementSyntaxNode(DoWhileStatementSyntaxNode* stmt)
     {
         RefPtr<DoWhileStatementSyntaxNode> loweredStmt = new DoWhileStatementSyntaxNode();
         lowerScopeStmtFields(loweredStmt, stmt);
@@ -805,7 +806,7 @@ struct LoweringVisitor
         assign(expr, createVarRef(expr->Position, varDecl));
     }
 
-    void visit(ReturnStatementSyntaxNode* stmt)
+    void visitReturnStatementSyntaxNode(ReturnStatementSyntaxNode* stmt)
     {
         auto loweredStmt = new ReturnStatementSyntaxNode();
         lowerStmtCommon(loweredStmt, stmt);
@@ -1004,59 +1005,59 @@ struct LoweringVisitor
 
     // Catch-all
 
-    RefPtr<Decl> visit(ModifierDecl*)
+    RefPtr<Decl> visitModifierDecl(ModifierDecl*)
     {
         // should not occur in user code
         SLANG_UNEXPECTED("modifiers shouldn't occur in user code");
     }
 
-    RefPtr<Decl> visit(GenericValueParamDecl*)
+    RefPtr<Decl> visitGenericValueParamDecl(GenericValueParamDecl*)
     {
         SLANG_UNEXPECTED("generics should be lowered to specialized decls");
     }
 
-    RefPtr<Decl> visit(GenericTypeParamDecl*)
+    RefPtr<Decl> visitGenericTypeParamDecl(GenericTypeParamDecl*)
     {
         SLANG_UNEXPECTED("generics should be lowered to specialized decls");
     }
 
-    RefPtr<Decl> visit(GenericTypeConstraintDecl*)
+    RefPtr<Decl> visitGenericTypeConstraintDecl(GenericTypeConstraintDecl*)
     {
         SLANG_UNEXPECTED("generics should be lowered to specialized decls");
     }
 
-    RefPtr<Decl> visit(GenericDecl*)
+    RefPtr<Decl> visitGenericDecl(GenericDecl*)
     {
         SLANG_UNEXPECTED("generics should be lowered to specialized decls");
     }
 
-    RefPtr<Decl> visit(ProgramSyntaxNode*)
+    RefPtr<Decl> visitProgramSyntaxNode(ProgramSyntaxNode*)
     {
         SLANG_UNEXPECTED("module decls should be lowered explicitly");
     }
 
-    RefPtr<Decl> visit(SubscriptDecl*)
+    RefPtr<Decl> visitSubscriptDecl(SubscriptDecl*)
     {
         // We don't expect to find direct references to a subscript
         // declaration, but rather to the underlying accessors
         return nullptr;
     }
 
-    RefPtr<Decl> visit(InheritanceDecl*)
+    RefPtr<Decl> visitInheritanceDecl(InheritanceDecl*)
     {
         // We should deal with these explicitly, as part of lowering
         // the type that contains them.
         return nullptr;
     }
 
-    RefPtr<Decl> visit(ExtensionDecl*)
+    RefPtr<Decl> visitExtensionDecl(ExtensionDecl*)
     {
         // Extensions won't exist in the lowered code: their members
         // will turn into ordinary functions that get called explicitly
         return nullptr;
     }
 
-    RefPtr<Decl> visit(TypeDefDecl* decl)
+    RefPtr<Decl> visitTypeDefDecl(TypeDefDecl* decl)
     {
         RefPtr<TypeDefDecl> loweredDecl = new TypeDefDecl();
         lowerDeclCommon(loweredDecl, decl);
@@ -1067,7 +1068,7 @@ struct LoweringVisitor
         return loweredDecl;
     }
 
-    RefPtr<ImportDecl> visit(ImportDecl* decl)
+    RefPtr<ImportDecl> visitImportDecl(ImportDecl* decl)
     {
         // No need to translate things here if we are
         // in "full" mode, because we will selectively
@@ -1086,7 +1087,7 @@ struct LoweringVisitor
         return nullptr;
     }
 
-    RefPtr<EmptyDecl> visit(EmptyDecl* decl)
+    RefPtr<EmptyDecl> visitEmptyDecl(EmptyDecl* decl)
     {
         // Empty declarations are really only useful in GLSL,
         // where they are used to hold metadata that doesn't
@@ -1103,7 +1104,7 @@ struct LoweringVisitor
         return loweredDecl;
     }
 
-    RefPtr<Decl> visit(AggTypeDecl* decl)
+    RefPtr<Decl> visitAggTypeDecl(AggTypeDecl* decl)
     {
         // We want to lower any aggregate type declaration
         // to just a `struct` type that contains its fields.
@@ -1145,7 +1146,7 @@ struct LoweringVisitor
         return loweredDecl;
     }
 
-    RefPtr<VarDeclBase> visit(
+    RefPtr<VarDeclBase> visitVariable(
         Variable* decl)
     {
         auto loweredDecl = lowerVarDeclCommon(new Variable(), decl);
@@ -1173,13 +1174,13 @@ struct LoweringVisitor
         return loweredDecl;
     }
 
-    RefPtr<VarDeclBase> visit(
+    RefPtr<VarDeclBase> visitStructField(
         StructField* decl)
     {
         return lowerVarDeclCommon(new StructField(), decl);
     }
 
-    RefPtr<VarDeclBase> visit(
+    RefPtr<VarDeclBase> visitParameterSyntaxNode(
         ParameterSyntaxNode* decl)
     {
         return lowerVarDeclCommon(new ParameterSyntaxNode(), decl);
@@ -1191,7 +1192,7 @@ struct LoweringVisitor
     }
 
 
-    RefPtr<Decl> visit(
+    RefPtr<Decl> visitDeclGroup(
         DeclGroup* group)
     {
         for (auto decl : group->decls)
@@ -1201,7 +1202,7 @@ struct LoweringVisitor
         return nullptr;
     }
 
-    RefPtr<FunctionSyntaxNode> visit(
+    RefPtr<FunctionSyntaxNode> visitFunctionDeclBase(
         FunctionDeclBase*   decl)
     {
         // TODO: need to generate a name
@@ -1474,7 +1475,7 @@ struct LoweringVisitor
         RefPtr<EntryPointLayout>    entryPointLayout)
     {
         // First, loer the entry-point function as an ordinary function:
-        auto loweredEntryPointFunc = visit(entryPointDecl);
+        auto loweredEntryPointFunc = visitFunctionDeclBase(entryPointDecl);
 
         // Now we will generate a `void main() { ... }` function to call the lowered code.
         RefPtr<FunctionSyntaxNode> mainDecl = new FunctionSyntaxNode();
@@ -1672,7 +1673,7 @@ struct LoweringVisitor
         {
         // Default case: lower an entry point just like any other function
         default:
-            return visit(entryPointDecl);
+            return visitFunctionDeclBase(entryPointDecl);
 
         // For Slang->GLSL translation, we need to lower things from HLSL-style
         // declarations over to GLSL conventions
diff --git a/source/slang/visitor.h b/source/slang/visitor.h
index 391769eca..eaddc5f32 100644
--- a/source/slang/visitor.h
+++ b/source/slang/visitor.h
@@ -24,8 +24,8 @@ struct ITypeVisitor
 #include "object-meta-end.h"
 };
 
-template<typename Derived, typename Result = void>
-struct TypeVisitor : ITypeVisitor
+template<typename Derived, typename Result = void, typename Base = ITypeVisitor>
+struct TypeVisitor : Base
 {
     Result dispatch(ExpressionType* type)
     {
@@ -37,16 +37,24 @@ struct TypeVisitor : ITypeVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void* extra) override \
-    { *(Result*)extra = ((Derived*) this)->visit(obj); }
+    { *(Result*)extra = ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "type-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    Result visit##NAME(NAME* obj) \
+    { return ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "type-defs.h"
+#include "object-meta-end.h"
 };
 
-template<typename Derived>
-struct TypeVisitor<Derived,void> : ITypeVisitor
+template<typename Derived, typename Base>
+struct TypeVisitor<Derived,void,Base> : Base
 {
     void dispatch(ExpressionType* type)
     {
@@ -56,12 +64,20 @@ struct TypeVisitor<Derived,void> : ITypeVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void*) override \
-    { ((Derived*) this)->visit(obj); }
+    { ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "type-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    void visit##NAME(NAME* obj) \
+    { ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "type-defs.h"
+#include "object-meta-end.h"
 };
 
 //
@@ -92,12 +108,20 @@ struct ExprVisitor : IExprVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void* extra) override \
-    { *(Result*)extra = ((Derived*) this)->visit(obj); }
+    { *(Result*)extra = ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "expr-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    Result visit##NAME(NAME* obj) \
+    { return ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "expr-defs.h"
+#include "object-meta-end.h"
 };
 
 template<typename Derived>
@@ -111,12 +135,20 @@ struct ExprVisitor<Derived,void> : IExprVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void*) override \
-    { ((Derived*) this)->visit(obj); }
+    { ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "expr-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    void visit##NAME(NAME* obj) \
+    { ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "expr-defs.h"
+#include "object-meta-end.h"
 };
 
 //
@@ -147,12 +179,20 @@ struct StmtVisitor : IStmtVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void* extra) override \
-    { *(Result*)extra = ((Derived*) this)->visit(obj); }
+    { *(Result*)extra = ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "stmt-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    Result visit##NAME(NAME* obj) \
+    { return ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "stmt-defs.h"
+#include "object-meta-end.h"
 };
 
 template<typename Derived>
@@ -166,12 +206,20 @@ struct StmtVisitor<Derived,void> : IStmtVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void*) override \
-    { ((Derived*) this)->visit(obj); }
+    { ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "stmt-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    void visit##NAME(NAME* obj) \
+    { ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "stmt-defs.h"
+#include "object-meta-end.h"
 };
 
 //
@@ -202,12 +250,20 @@ struct DeclVisitor : IDeclVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void* extra) override \
-    { *(Result*)extra = ((Derived*) this)->visit(obj); }
+    { *(Result*)extra = ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "decl-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    Result visit##NAME(NAME* obj) \
+    { return ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "decl-defs.h"
+#include "object-meta-end.h"
 };
 
 template<typename Derived>
@@ -221,12 +277,20 @@ struct DeclVisitor<Derived,void> : IDeclVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void*) override \
-    { ((Derived*) this)->visit(obj); }
+    { ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "decl-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    void visit##NAME(NAME* obj) \
+    { ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "decl-defs.h"
+#include "object-meta-end.h"
 };
 
 //
@@ -257,12 +321,20 @@ struct ModifierVisitor : IModifierVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void* extra) override \
-    { *(Result*)extra = ((Derived*) this)->visit(obj); }
+    { *(Result*)extra = ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "modifier-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    Result visit##NAME(NAME* obj) \
+    { return ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "modifier-defs.h"
+#include "object-meta-end.h"
 };
 
 template<typename Derived>
@@ -276,12 +348,20 @@ struct ModifierVisitor<Derived, void> : IModifierVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void*) override \
-    { ((Derived*) this)->visit(obj); }
+    { ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "modifier-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    void visit##NAME(NAME* obj) \
+    { ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "modifier-defs.h"
+#include "object-meta-end.h"
 };
 
 //
@@ -299,8 +379,8 @@ struct IValVisitor : ITypeVisitor
 #include "object-meta-end.h"
 };
 
-template<typename Derived, typename Result = void>
-struct ValVisitor : IValVisitor
+template<typename Derived, typename Result = void, typename TypeResult = void>
+struct ValVisitor : TypeVisitor<Derived, TypeResult, IValVisitor>
 {
     Result dispatch(Val* val)
     {
@@ -312,17 +392,24 @@ struct ValVisitor : IValVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void* extra) override \
-    { *(Result*)extra = ((Derived*) this)->visit(obj); }
+    { *(Result*)extra = ((Derived*) this)->visit##NAME(obj); }
 
 #include "object-meta-begin.h"
 #include "val-defs.h"
-#include "type-defs.h"
 #include "object-meta-end.h"
 
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    Result visit##NAME(NAME* obj) \
+    { return ((Derived*) this)->visit##BASE(obj); }
+
+#include "object-meta-begin.h"
+#include "val-defs.h"
+#include "object-meta-end.h"
 };
 
 template<typename Derived>
-struct ValVisitor<Derived, void> : IValVisitor
+struct ValVisitor<Derived, void, void> : TypeVisitor<Derived, void, IValVisitor>
 {
     void dispatch(Val* val)
     {
@@ -332,11 +419,19 @@ struct ValVisitor<Derived, void> : IValVisitor
 #define ABSTRACT_SYNTAX_CLASS(NAME,BASE) /* empty */
 #define SYNTAX_CLASS(NAME, BASE) \
     virtual void dispatch_##NAME(NAME* obj, void*) override \
-    { ((Derived*) this)->visit(obj); }
+    { ((Derived*) this)->visit##NAME(obj); }
+
+#include "object-meta-begin.h"
+#include "val-defs.h"
+#include "object-meta-end.h"
+
+#define ABSTRACT_SYNTAX_CLASS(NAME,BASE) SYNTAX_CLASS(NAME, BASE)
+#define SYNTAX_CLASS(NAME, BASE) \
+    void visit##NAME(NAME* obj) \
+    { ((Derived*) this)->visit##BASE(obj); }
 
 #include "object-meta-begin.h"
 #include "val-defs.h"
-#include "type-defs.h"
 #include "object-meta-end.h"
 
 };