Add meta-definitions for AST types

- The big change here is that all the definitions for syntax-node classes have been macro-ized, to that we can do light metaprogramming over them
  - The use of macros for this has big down-sides, but I'm not quite ready to do anything more heavy-weight right now
  - The macro-ized definitions can be included multiple times, to generate different declarations/code as needed

- The first example of using this meta-programming facility is a new visitor system
  - The actual visitor base classes and the dispatch logic are all generated from the meta-files

- There was only one visitor left in the code: the semantics checker, so that was ported to the new system.

- All current test cases pass, so *of course* that means all is well.

1 files changed, 33 insertions, 473 deletions

diff --git a/source/slang/syntax.cpp b/source/slang/syntax.cpp
index cf529e55e..983f18bb7 100644
--- a/source/slang/syntax.cpp
+++ b/source/slang/syntax.cpp
@@ -1,5 +1,9 @@
 #include "syntax.h"
-#include "syntax-visitors.h"
+
+#pragma warning AAA
+#include "visitor.h"
+#pragma warning BBB
+
 #include <typeinfo>
 #include <assert.h>
 
@@ -51,176 +55,47 @@ namespace Slang
         return res.ProduceString();
     }
 
-    RefPtr<SyntaxNode> ProgramSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitProgram(this);
-    }
-
-    RefPtr<SyntaxNode> FunctionSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitFunction(this);
-    }
-
-    //
-
-    RefPtr<SyntaxNode> ScopeDecl::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitScopeDecl(this);
-    }
-
-    //
+#pragma warning CCC
 
-    RefPtr<SyntaxNode> BlockStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitBlockStatement(this);
-    }
 
-    RefPtr<SyntaxNode> BreakStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitBreakStatement(this);
-    }
+    // Generate dispatch logic and other definitions for all syntax classes
+#define SYNTAX_CLASS(NAME, BASE) /* empty */
+#include "object-meta-begin.h"
 
-    RefPtr<SyntaxNode> ContinueStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitContinueStatement(this);
-    }
+#include "syntax-base-defs.h"
+#undef SYNTAX_CLASS
+#undef ABSTRACT_SYNTAX_CLASS
 
-    RefPtr<SyntaxNode> DoWhileStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitDoWhileStatement(this);
-    }
+#define ABSTRACT_SYNTAX_CLASS(NAME, BASE) /* empty */
+#define SYNTAX_CLASS(NAME, BASE)                                \
+    void NAME::accept(NAME::Visitor* visitor, void* extra)      \
+    { visitor->dispatch_##NAME(this, extra); }
+#include "expr-defs.h"
+#include "decl-defs.h"
+#include "modifier-defs.h"
+#include "stmt-defs.h"
+#include "type-defs.h"
+#include "val-defs.h"
 
-    RefPtr<SyntaxNode> EmptyStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitEmptyStatement(this);
-    }
+#include "object-meta-end.h"
 
-    RefPtr<SyntaxNode> ForStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitForStatement(this);
-    }
+#pragma warning DDD
 
-    RefPtr<SyntaxNode> IfStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitIfStatement(this);
-    }
-
-    RefPtr<SyntaxNode> ReturnStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitReturnStatement(this);
-    }
-
-    RefPtr<SyntaxNode> VarDeclrStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitVarDeclrStatement(this);
-    }
-
-    RefPtr<SyntaxNode> Variable::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitDeclrVariable(this);
-    }
-
-    RefPtr<SyntaxNode> WhileStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitWhileStatement(this);
-    }
-
-    RefPtr<SyntaxNode> ExpressionStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitExpressionStatement(this);
-    }
-
-    RefPtr<SyntaxNode> ConstantExpressionSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitConstantExpression(this);
-    }
-
-    RefPtr<SyntaxNode> IndexExpressionSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitIndexExpression(this);
-    }
-    RefPtr<SyntaxNode> MemberExpressionSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitMemberExpression(this);
-    }
-
-    // SwizzleExpr
-
-    RefPtr<SyntaxNode> SwizzleExpr::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitSwizzleExpression(this);
-    }
-
-    // DerefExpr
-
-    RefPtr<SyntaxNode> DerefExpr::Accept(SyntaxVisitor * /*visitor*/)
-    {
-        // throw "unimplemented";
-        return this;
-    }
-
-    //
-
-    RefPtr<SyntaxNode> InvokeExpressionSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitInvokeExpression(this);
-    }
-
-    RefPtr<SyntaxNode> TypeCastExpressionSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitTypeCastExpression(this);
-    }
-
-    RefPtr<SyntaxNode> VarExpressionSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitVarExpression(this);
-    }
-
-    // OverloadedExpr
-
-    RefPtr<SyntaxNode> OverloadedExpr::Accept(SyntaxVisitor * /*visitor*/)
-    {
-//			throw "unimplemented";
-        return this;
-    }
-
-    //
-
-    RefPtr<SyntaxNode> ParameterSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitParameter(this);
-    }
-
-    // ImportDecl
-
-    RefPtr<SyntaxNode> ImportDecl::Accept(SyntaxVisitor * visitor)
-    {
-        visitor->visitImportDecl(this);
-        return this;
-    }
+void ExpressionType::accept(IValVisitor* visitor, void* extra)
+{
+    accept((ITypeVisitor*)visitor, extra);
+}
 
-    //
+    // TypeExp
 
-    RefPtr<SyntaxNode> StructField::Accept(SyntaxVisitor * visitor)
+    bool TypeExp::Equals(ExpressionType* other)
     {
-        return visitor->VisitStructField(this);
-    }
-    RefPtr<SyntaxNode> StructSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitStruct(this);
-    }
-    RefPtr<SyntaxNode> ClassSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitClass(this);
-    }
-    RefPtr<SyntaxNode> TypeDefDecl::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitTypeDefDecl(this);
+        return type->Equals(other);
     }
 
-    RefPtr<SyntaxNode> DiscardStatementSyntaxNode::Accept(SyntaxVisitor * visitor)
+    bool TypeExp::Equals(RefPtr<ExpressionType> other)
     {
-        return visitor->VisitDiscardStatement(this);
+        return type->Equals(other.Ptr());
     }
 
     // BasicExpressionType
@@ -358,10 +233,6 @@ namespace Slang
         else
             return BaseType->ToString() + "[]";
     }
-    RefPtr<SyntaxNode> GenericAppExpr::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitGenericApp(this);
-    }
 
     // DeclRefType
 
@@ -826,190 +697,6 @@ namespace Slang
         return this->declRef.substitutions->args[2].As<IntVal>().Ptr();
     }
 
-    //
-
-#if 0
-    String GetOperatorFunctionName(Operator op)
-    {
-        switch (op)
-        {
-        case Operator::Add:
-        case Operator::AddAssign:
-            return "+";
-        case Operator::Sub:
-        case Operator::SubAssign:
-            return "-";
-        case Operator::Neg:
-            return "-";
-        case Operator::Not:
-            return "!";
-        case Operator::BitNot:
-            return "~";
-        case Operator::PreInc:
-        case Operator::PostInc:
-            return "++";
-        case Operator::PreDec:
-        case Operator::PostDec:
-            return "--";
-        case Operator::Mul:
-        case Operator::MulAssign:
-            return "*";
-        case Operator::Div:
-        case Operator::DivAssign:
-            return "/";
-        case Operator::Mod:
-        case Operator::ModAssign:
-            return "%";
-        case Operator::Lsh:
-        case Operator::LshAssign:
-            return "<<";
-        case Operator::Rsh:
-        case Operator::RshAssign:
-            return ">>";
-        case Operator::Eql:
-            return "==";
-        case Operator::Neq:
-            return "!=";
-        case Operator::Greater:
-            return ">";
-        case Operator::Less:
-            return "<";
-        case Operator::Geq:
-            return ">=";
-        case Operator::Leq:
-            return "<=";
-        case Operator::BitAnd:
-        case Operator::AndAssign:
-            return "&";
-        case Operator::BitXor:
-        case Operator::XorAssign:
-            return "^";
-        case Operator::BitOr:
-        case Operator::OrAssign:
-            return "|";
-        case Operator::And:
-            return "&&";
-        case Operator::Or:
-            return "||";
-        case Operator::Sequence:
-            return ",";
-        case Operator::Select:
-            return "?:";
-        case Operator::Assign:
-            return "=";
-        default:
-            return "";
-        }
-    }
-#endif
-    String OperatorToString(Operator op)
-    {
-        switch (op)
-        {
-        case Slang::Operator::Neg:
-            return "-";
-        case Slang::Operator::Not:
-            return "!";
-        case Slang::Operator::PreInc:
-            return "++";
-        case Slang::Operator::PreDec:
-            return "--";
-        case Slang::Operator::PostInc:
-            return "++";
-        case Slang::Operator::PostDec:
-            return "--";
-        case Slang::Operator::Mul:
-        case Slang::Operator::MulAssign:
-            return "*";
-        case Slang::Operator::Div:
-        case Slang::Operator::DivAssign:
-            return "/";
-        case Slang::Operator::Mod:
-        case Slang::Operator::ModAssign:
-            return "%";
-        case Slang::Operator::Add:
-        case Slang::Operator::AddAssign:
-            return "+";
-        case Slang::Operator::Sub:
-        case Slang::Operator::SubAssign:
-            return "-";
-        case Slang::Operator::Lsh:
-        case Slang::Operator::LshAssign:
-            return "<<";
-        case Slang::Operator::Rsh:
-        case Slang::Operator::RshAssign:
-            return ">>";
-        case Slang::Operator::Eql:
-            return "==";
-        case Slang::Operator::Neq:
-            return "!=";
-        case Slang::Operator::Greater:
-            return ">";
-        case Slang::Operator::Less:
-            return "<";
-        case Slang::Operator::Geq:
-            return ">=";
-        case Slang::Operator::Leq:
-            return "<=";
-        case Slang::Operator::BitAnd:
-        case Slang::Operator::AndAssign:
-            return "&";
-        case Slang::Operator::BitXor:
-        case Slang::Operator::XorAssign:
-            return "^";
-        case Slang::Operator::BitOr:
-        case Slang::Operator::OrAssign:
-            return "|";
-        case Slang::Operator::And:
-            return "&&";
-        case Slang::Operator::Or:
-            return "||";
-        case Slang::Operator::Assign:
-            return "=";
-        default:
-            return "ERROR";
-        }
-    }
-
-    // TypeExp
-
-    TypeExp TypeExp::Accept(SyntaxVisitor* visitor)
-    {
-        return visitor->VisitTypeExp(*this);
-    }
-
-    // BuiltinTypeModifier
-
-    // MagicTypeModifier
-
-    // GenericDecl
-
-    RefPtr<SyntaxNode> GenericDecl::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitGenericDecl(this);
-    }
-
-    // GenericTypeParamDecl
-
-    RefPtr<SyntaxNode> GenericTypeParamDecl::Accept(SyntaxVisitor * /*visitor*/) {
-        //throw "unimplemented";
-        return this;
-    }
-
-    // GenericTypeConstraintDecl
-
-    RefPtr<SyntaxNode> GenericTypeConstraintDecl::Accept(SyntaxVisitor * visitor)
-    {
-        return this;
-    }
-
-    // GenericValueParamDecl
-
-    RefPtr<SyntaxNode> GenericValueParamDecl::Accept(SyntaxVisitor * /*visitor*/) {
-        //throw "unimplemented";
-        return this;
-    }
-
     // GenericParamIntVal
 
     bool GenericParamIntVal::EqualsVal(Val* val)
@@ -1069,38 +756,6 @@ namespace Slang
         return this;
     }
 
-    // ExtensionDecl
-
-    RefPtr<SyntaxNode> ExtensionDecl::Accept(SyntaxVisitor * visitor)
-    {
-        visitor->VisitExtensionDecl(this);
-        return this;
-    }
-
-    // ConstructorDecl
-
-    RefPtr<SyntaxNode> ConstructorDecl::Accept(SyntaxVisitor * visitor)
-    {
-        visitor->VisitConstructorDecl(this);
-        return this;
-    }
-
-    // SubscriptDecl
-
-    RefPtr<SyntaxNode> SubscriptDecl::Accept(SyntaxVisitor * visitor)
-    {
-        visitor->visitSubscriptDecl(this);
-        return this;
-    }
-
-    // AccessorDecl
-
-    RefPtr<SyntaxNode> AccessorDecl::Accept(SyntaxVisitor * visitor)
-    {
-        visitor->visitAccessorDecl(this);
-        return this;
-    }
-
     // Substitutions
 
     RefPtr<Substitutions> Substitutions::SubstituteImpl(Substitutions* subst, int* ioDiff)
@@ -1297,73 +952,6 @@ namespace Slang
         return (int) value;
     }
 
-    // SwitchStmt
-
-    RefPtr<SyntaxNode> SwitchStmt::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitSwitchStmt(this);
-    }
-
-    RefPtr<SyntaxNode> CaseStmt::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitCaseStmt(this);
-    }
-
-    RefPtr<SyntaxNode> DefaultStmt::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitDefaultStmt(this);
-    }
-
-    // InterfaceDecl
-
-    RefPtr<SyntaxNode> InterfaceDecl::Accept(SyntaxVisitor * visitor)
-    {
-        visitor->visitInterfaceDecl(this);
-        return this;
-    }
-
-    // InheritanceDecl
-
-    RefPtr<SyntaxNode> InheritanceDecl::Accept(SyntaxVisitor * visitor)
-    {
-        visitor->visitInheritanceDecl(this);
-        return this;
-    }
-
-    // SharedTypeExpr
-
-    RefPtr<SyntaxNode> SharedTypeExpr::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitSharedTypeExpr(this);
-    }
-
-    // OperatorExpressionSyntaxNode
-
-#if 0
-    void OperatorExpressionSyntaxNode::SetOperator(RefPtr<Scope> scope, Slang::Operator op)
-    {
-        this->Operator = op;
-        auto opExpr = new VarExpressionSyntaxNode();
-        opExpr->Variable = GetOperatorFunctionName(Operator);
-        opExpr->scope = scope;
-        opExpr->Position = this->Position;
-        this->FunctionExpr = opExpr;
-    }
-#endif
-
-    RefPtr<SyntaxNode> OperatorExpressionSyntaxNode::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->VisitOperatorExpression(this);
-    }
-
-    // DeclGroup
-
-    RefPtr<SyntaxNode> DeclGroup::Accept(SyntaxVisitor * visitor)
-    {
-        visitor->VisitDeclGroup(this);
-        return this;
-    }
-
     //
 
     void RegisterBuiltinDecl(
@@ -1429,34 +1017,6 @@ namespace Slang
 
     //
 
-    RefPtr<SyntaxNode> UnparsedStmt::Accept(SyntaxVisitor * visitor)
-    {
-        return this;
-    }
-
-    //
-
-    RefPtr<SyntaxNode> InitializerListExpr::Accept(SyntaxVisitor * visitor)
-    {
-        return visitor->visitInitializerListExpr(this);
-    }
-
-    //
-
-    RefPtr<SyntaxNode> ModifierDecl::Accept(SyntaxVisitor * visitor)
-    {
-        return this;
-    }
-
-    //
-
-    RefPtr<SyntaxNode> EmptyDecl::Accept(SyntaxVisitor * visitor)
-    {
-        return this;
-    }
-
-    //
-
     SyntaxNodeBase* createInstanceOfSyntaxClassByName(
         String const&   name)
     {