Merge pull request #155 from tfoleyNV/renaming

Major naming overhaul:

1 files changed, 36 insertions, 36 deletions

diff --git a/source/slang/expr-defs.h b/source/slang/expr-defs.h
index dc93407e0..1860f8a72 100644
--- a/source/slang/expr-defs.h
+++ b/source/slang/expr-defs.h
@@ -4,7 +4,7 @@
 
 
 // Base class for expressions that will reference declarations
-ABSTRACT_SYNTAX_CLASS(DeclRefExpr, ExpressionSyntaxNode)
+ABSTRACT_SYNTAX_CLASS(DeclRefExpr, Expr)
 
 // The scope in which to perform lookup
     FIELD(RefPtr<Scope>, scope)
@@ -16,21 +16,21 @@ ABSTRACT_SYNTAX_CLASS(DeclRefExpr, ExpressionSyntaxNode)
     FIELD(String, name)
 END_SYNTAX_CLASS()
 
-SIMPLE_SYNTAX_CLASS(VarExpressionSyntaxNode, DeclRefExpr)
+SIMPLE_SYNTAX_CLASS(VarExpr, DeclRefExpr)
 
 // An expression that references an overloaded set of declarations
 // having the same name.
-SYNTAX_CLASS(OverloadedExpr, ExpressionSyntaxNode)
+SYNTAX_CLASS(OverloadedExpr, Expr)
 
     // Optional: the base expression is this overloaded result
     // arose from a member-reference expression.
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, base)
+    SYNTAX_FIELD(RefPtr<Expr>, base)
 
     // The lookup result that was ambiguous
     FIELD(LookupResult, lookupResult2)
 END_SYNTAX_CLASS()
 
-SYNTAX_CLASS(ConstantExpressionSyntaxNode, ExpressionSyntaxNode)
+SYNTAX_CLASS(ConstantExpr, Expr)
     FIELD(Token, token)
 
     RAW(
@@ -52,13 +52,13 @@ SYNTAX_CLASS(ConstantExpressionSyntaxNode, ExpressionSyntaxNode)
 END_SYNTAX_CLASS()
 
 // An initializer list, e.g. `{ 1, 2, 3 }`
-SYNTAX_CLASS(InitializerListExpr, ExpressionSyntaxNode)
-    SYNTAX_FIELD(List<RefPtr<ExpressionSyntaxNode>>, args)
+SYNTAX_CLASS(InitializerListExpr, Expr)
+    SYNTAX_FIELD(List<RefPtr<Expr>>, args)
 END_SYNTAX_CLASS()
 
 // A base class for expressions with arguments
-ABSTRACT_SYNTAX_CLASS(ExprWithArgsBase, ExpressionSyntaxNode)
-    SYNTAX_FIELD(List<RefPtr<ExpressionSyntaxNode>>, Arguments)
+ABSTRACT_SYNTAX_CLASS(ExprWithArgsBase, Expr)
+    SYNTAX_FIELD(List<RefPtr<Expr>>, Arguments)
 END_SYNTAX_CLASS()
 
 // An aggregate type constructor
@@ -70,49 +70,49 @@ END_SYNTAX_CLASS()
 // A base expression being applied to arguments: covers
 // both ordinary `()` function calls and `<>` generic application
 ABSTRACT_SYNTAX_CLASS(AppExprBase, ExprWithArgsBase)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, FunctionExpr)
+    SYNTAX_FIELD(RefPtr<Expr>, FunctionExpr)
 END_SYNTAX_CLASS()
 
-SIMPLE_SYNTAX_CLASS(InvokeExpressionSyntaxNode, AppExprBase)
+SIMPLE_SYNTAX_CLASS(InvokeExpr, AppExprBase)
 
-SIMPLE_SYNTAX_CLASS(OperatorExpressionSyntaxNode, InvokeExpressionSyntaxNode)
+SIMPLE_SYNTAX_CLASS(OperatorExpr, InvokeExpr)
 
-SIMPLE_SYNTAX_CLASS(InfixExpr  , OperatorExpressionSyntaxNode)
-SIMPLE_SYNTAX_CLASS(PrefixExpr , OperatorExpressionSyntaxNode)
-SIMPLE_SYNTAX_CLASS(PostfixExpr, OperatorExpressionSyntaxNode)
+SIMPLE_SYNTAX_CLASS(InfixExpr  , OperatorExpr)
+SIMPLE_SYNTAX_CLASS(PrefixExpr , OperatorExpr)
+SIMPLE_SYNTAX_CLASS(PostfixExpr, OperatorExpr)
 
-SYNTAX_CLASS(IndexExpressionSyntaxNode, ExpressionSyntaxNode)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, BaseExpression)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, IndexExpression)
+SYNTAX_CLASS(IndexExpr, Expr)
+    SYNTAX_FIELD(RefPtr<Expr>, BaseExpression)
+    SYNTAX_FIELD(RefPtr<Expr>, IndexExpression)
 END_SYNTAX_CLASS()
 
-SYNTAX_CLASS(MemberExpressionSyntaxNode, DeclRefExpr)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, BaseExpression)
+SYNTAX_CLASS(MemberExpr, DeclRefExpr)
+    SYNTAX_FIELD(RefPtr<Expr>, BaseExpression)
 END_SYNTAX_CLASS()
 
-SYNTAX_CLASS(SwizzleExpr, ExpressionSyntaxNode)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, base)
+SYNTAX_CLASS(SwizzleExpr, Expr)
+    SYNTAX_FIELD(RefPtr<Expr>, base)
     FIELD(int, elementCount)
     FIELD(int, elementIndices[4])
 END_SYNTAX_CLASS()
 
 // A dereference of a pointer or pointer-like type
-SYNTAX_CLASS(DerefExpr, ExpressionSyntaxNode)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, base)
+SYNTAX_CLASS(DerefExpr, Expr)
+    SYNTAX_FIELD(RefPtr<Expr>, base)
 END_SYNTAX_CLASS()
 
 // Any operation that performs type-casting
-SYNTAX_CLASS(TypeCastExpressionSyntaxNode, ExpressionSyntaxNode)
+SYNTAX_CLASS(TypeCastExpr, Expr)
     SYNTAX_FIELD(TypeExp, TargetType)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, Expression)
+    SYNTAX_FIELD(RefPtr<Expr>, Expression)
 END_SYNTAX_CLASS()
 
-// An explicit type-cast that appear in the user's code with `(Type) expr` syntax
-SYNTAX_CLASS(ExplicitCastExpr, TypeCastExpressionSyntaxNode)
+// An explicit type-cast that appear in the user's code with `(type) expr` syntax
+SYNTAX_CLASS(ExplicitCastExpr, TypeCastExpr)
 END_SYNTAX_CLASS()
 
 // An implicit type-cast inserted during semantic checking
-SYNTAX_CLASS(ImplicitCastExpr, TypeCastExpressionSyntaxNode)
+SYNTAX_CLASS(ImplicitCastExpr, TypeCastExpr)
 END_SYNTAX_CLASS()
 
 // An implicit type-cast that should also be hidden on output,
@@ -120,26 +120,26 @@ END_SYNTAX_CLASS()
 SYNTAX_CLASS(HiddenImplicitCastExpr, ImplicitCastExpr)
 END_SYNTAX_CLASS()
 
-SIMPLE_SYNTAX_CLASS(SelectExpressionSyntaxNode, OperatorExpressionSyntaxNode)
+SIMPLE_SYNTAX_CLASS(SelectExpr, OperatorExpr)
 
 SIMPLE_SYNTAX_CLASS(GenericAppExpr, AppExprBase)
 
 // An expression representing re-use of the syntax for a type in more
 // than once conceptually-distinct declaration
-SYNTAX_CLASS(SharedTypeExpr, ExpressionSyntaxNode)
+SYNTAX_CLASS(SharedTypeExpr, Expr)
     // The underlying type expression that we want to share
     SYNTAX_FIELD(TypeExp, base)
 END_SYNTAX_CLASS()
 
-SYNTAX_CLASS(AssignExpr, ExpressionSyntaxNode)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, left);
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, right);
+SYNTAX_CLASS(AssignExpr, Expr)
+    SYNTAX_FIELD(RefPtr<Expr>, left);
+    SYNTAX_FIELD(RefPtr<Expr>, right);
 END_SYNTAX_CLASS()
 
 // Just an expression inside parentheses `(exp)`
 //
 // We keep this around explicitly to be sure we don't lose any structure
 // when we do rewriter stuff.
-SYNTAX_CLASS(ParenExpr, ExpressionSyntaxNode)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, base);
+SYNTAX_CLASS(ParenExpr, Expr)
+    SYNTAX_FIELD(RefPtr<Expr>, base);
 END_SYNTAX_CLASS()