Merge pull request #155 from tfoleyNV/renaming

Major naming overhaul:

31 files changed, 1202 insertions, 1482 deletions

diff --git a/source/slang/check.cpp b/source/slang/check.cpp
index 4c73894c5..23394e107 100644
--- a/source/slang/check.cpp
+++ b/source/slang/check.cpp
@@ -44,7 +44,7 @@ namespace Slang
     }
 
     struct SemanticsVisitor
-        : ExprVisitor<SemanticsVisitor, RefPtr<ExpressionSyntaxNode>>
+        : ExprVisitor<SemanticsVisitor, RefPtr<Expr>>
         , StmtVisitor<SemanticsVisitor>
         , DeclVisitor<SemanticsVisitor>
     {
@@ -54,8 +54,8 @@ namespace Slang
             return sink;
         }
 
-//        ProgramSyntaxNode * program = nullptr;
-        FunctionSyntaxNode * function = nullptr;
+//        ModuleDecl * program = nullptr;
+        FuncDecl * function = nullptr;
 
         CompileRequest* request = nullptr;
         TranslationUnitRequest* translationUnit = nullptr;
@@ -66,14 +66,14 @@ namespace Slang
         }
 
         // lexical outer statements
-        List<StatementSyntaxNode*> outerStmts;
+        List<Stmt*> outerStmts;
 
         // We need to track what has been `import`ed,
         // to avoid importing the same thing more than once
         //
         // TODO: a smarter approach might be to filter
         // out duplicate references during lookup.
-        HashSet<ProgramSyntaxNode*> importedModules;
+        HashSet<ModuleDecl*> importedModules;
 
     public:
         SemanticsVisitor(
@@ -95,8 +95,8 @@ namespace Slang
 
     public:
         // Translate Types
-        RefPtr<ExpressionType> typeResult;
-        RefPtr<ExpressionSyntaxNode> TranslateTypeNodeImpl(const RefPtr<ExpressionSyntaxNode> & node)
+        RefPtr<Type> typeResult;
+        RefPtr<Expr> TranslateTypeNodeImpl(const RefPtr<Expr> & node)
         {
             if (!node) return nullptr;
 
@@ -104,16 +104,16 @@ namespace Slang
             expr = ExpectATypeRepr(expr);
             return expr;
         }
-        RefPtr<ExpressionType> ExtractTypeFromTypeRepr(const RefPtr<ExpressionSyntaxNode>& typeRepr)
+        RefPtr<Type> ExtractTypeFromTypeRepr(const RefPtr<Expr>& typeRepr)
         {
             if (!typeRepr) return nullptr;
-            if (auto typeType = typeRepr->Type->As<TypeType>())
+            if (auto typeType = typeRepr->type->As<TypeType>())
             {
                 return typeType->type;
             }
             return getSession()->getErrorType();
         }
-        RefPtr<ExpressionType> TranslateTypeNode(const RefPtr<ExpressionSyntaxNode> & node)
+        RefPtr<Type> TranslateTypeNode(const RefPtr<Expr> & node)
         {
             if (!node) return nullptr;
             auto typeRepr = TranslateTypeNodeImpl(node);
@@ -139,53 +139,53 @@ namespace Slang
             return result;
         }
 
-        RefPtr<ExpressionSyntaxNode> ConstructDeclRefExpr(
+        RefPtr<Expr> ConstructDeclRefExpr(
             DeclRef<Decl>                     declRef,
-            RefPtr<ExpressionSyntaxNode>    baseExpr,
-            RefPtr<ExpressionSyntaxNode>    originalExpr)
+            RefPtr<Expr>    baseExpr,
+            RefPtr<Expr>    originalExpr)
         {
             if (baseExpr)
             {
-                auto expr = new MemberExpressionSyntaxNode();
+                auto expr = new MemberExpr();
                 expr->Position = originalExpr->Position;
                 expr->BaseExpression = baseExpr;
                 expr->name = declRef.GetName();
-                expr->Type = GetTypeForDeclRef(declRef);
+                expr->type = GetTypeForDeclRef(declRef);
                 expr->declRef = declRef;
                 return expr;
             }
             else
             {
-                auto expr = new VarExpressionSyntaxNode();
+                auto expr = new VarExpr();
                 expr->Position = originalExpr->Position;
                 expr->name = declRef.GetName();
-                expr->Type = GetTypeForDeclRef(declRef);
+                expr->type = GetTypeForDeclRef(declRef);
                 expr->declRef = declRef;
                 return expr;
             }
         }
 
-        RefPtr<ExpressionSyntaxNode> ConstructDerefExpr(
-            RefPtr<ExpressionSyntaxNode> base,
-            RefPtr<ExpressionSyntaxNode> originalExpr)
+        RefPtr<Expr> ConstructDerefExpr(
+            RefPtr<Expr> base,
+            RefPtr<Expr> originalExpr)
         {
-            auto ptrLikeType = base->Type->As<PointerLikeType>();
+            auto ptrLikeType = base->type->As<PointerLikeType>();
             SLANG_ASSERT(ptrLikeType);
 
             auto derefExpr = new DerefExpr();
             derefExpr->Position = originalExpr->Position;
             derefExpr->base = base;
-            derefExpr->Type = QualType(ptrLikeType->elementType);
+            derefExpr->type = QualType(ptrLikeType->elementType);
 
             // TODO(tfoley): handle l-value status here
 
             return derefExpr;
         }
 
-        RefPtr<ExpressionSyntaxNode> ConstructLookupResultExpr(
+        RefPtr<Expr> ConstructLookupResultExpr(
             LookupResultItem const&			item,
-            RefPtr<ExpressionSyntaxNode>	baseExpr,
-            RefPtr<ExpressionSyntaxNode>	originalExpr)
+            RefPtr<Expr>	baseExpr,
+            RefPtr<Expr>	originalExpr)
         {
             // If we collected any breadcrumbs, then these represent
             // additional segments of the lookup path that we need
@@ -209,16 +209,16 @@ namespace Slang
             return ConstructDeclRefExpr(item.declRef, bb, originalExpr);
         }
 
-        RefPtr<ExpressionSyntaxNode> createLookupResultExpr(
+        RefPtr<Expr> createLookupResultExpr(
             LookupResult const&             lookupResult,
-            RefPtr<ExpressionSyntaxNode>    baseExpr,
-            RefPtr<ExpressionSyntaxNode>    originalExpr)
+            RefPtr<Expr>    baseExpr,
+            RefPtr<Expr>    originalExpr)
         {
             if (lookupResult.isOverloaded())
             {
                 auto overloadedExpr = new OverloadedExpr();
                 overloadedExpr->Position = originalExpr->Position;
-                overloadedExpr->Type = QualType(
+                overloadedExpr->type = QualType(
                     getSession()->getOverloadedType());
                 overloadedExpr->base = baseExpr;
                 overloadedExpr->lookupResult2 = lookupResult;
@@ -230,7 +230,7 @@ namespace Slang
             }
         }
 
-        RefPtr<ExpressionSyntaxNode> ResolveOverloadedExpr(RefPtr<OverloadedExpr> overloadedExpr, LookupMask mask)
+        RefPtr<Expr> ResolveOverloadedExpr(RefPtr<OverloadedExpr> overloadedExpr, LookupMask mask)
         {
             auto lookupResult = overloadedExpr->lookupResult2;
             SLANG_RELEASE_ASSERT(lookupResult.isValid() && lookupResult.isOverloaded());
@@ -267,18 +267,18 @@ namespace Slang
             return ConstructLookupResultExpr(lookupResult.item, overloadedExpr->base, overloadedExpr);
         }
 
-        RefPtr<ExpressionSyntaxNode> ExpectATypeRepr(RefPtr<ExpressionSyntaxNode> expr)
+        RefPtr<Expr> ExpectATypeRepr(RefPtr<Expr> expr)
         {
             if (auto overloadedExpr = expr.As<OverloadedExpr>())
             {
-                expr = ResolveOverloadedExpr(overloadedExpr, LookupMask::Type);
+                expr = ResolveOverloadedExpr(overloadedExpr, LookupMask::type);
             }
 
-            if (auto typeType = expr->Type.type->As<TypeType>())
+            if (auto typeType = expr->type.type->As<TypeType>())
             {
                 return expr;
             }
-            else if (auto errorType = expr->Type.type->As<ErrorType>())
+            else if (auto errorType = expr->type.type->As<ErrorType>())
             {
                 return expr;
             }
@@ -290,41 +290,41 @@ namespace Slang
             return CreateErrorExpr(expr);
         }
 
-        RefPtr<ExpressionType> ExpectAType(RefPtr<ExpressionSyntaxNode> expr)
+        RefPtr<Type> ExpectAType(RefPtr<Expr> expr)
         {
             auto typeRepr = ExpectATypeRepr(expr);
-            if (auto typeType = typeRepr->Type->As<TypeType>())
+            if (auto typeType = typeRepr->type->As<TypeType>())
             {
                 return typeType->type;
             }
             return getSession()->getErrorType();
         }
 
-        RefPtr<ExpressionType> ExtractGenericArgType(RefPtr<ExpressionSyntaxNode> exp)
+        RefPtr<Type> ExtractGenericArgType(RefPtr<Expr> exp)
         {
             return ExpectAType(exp);
         }
 
-        RefPtr<IntVal> ExtractGenericArgInteger(RefPtr<ExpressionSyntaxNode> exp)
+        RefPtr<IntVal> ExtractGenericArgInteger(RefPtr<Expr> exp)
         {
             return CheckIntegerConstantExpression(exp.Ptr());
         }
 
-        RefPtr<Val> ExtractGenericArgVal(RefPtr<ExpressionSyntaxNode> exp)
+        RefPtr<Val> ExtractGenericArgVal(RefPtr<Expr> exp)
         {
             if (auto overloadedExpr = exp.As<OverloadedExpr>())
             {
                 // assume that if it is overloaded, we want a type
-                exp = ResolveOverloadedExpr(overloadedExpr, LookupMask::Type);
+                exp = ResolveOverloadedExpr(overloadedExpr, LookupMask::type);
             }
 
-            if (auto typeType = exp->Type->As<TypeType>())
+            if (auto typeType = exp->type->As<TypeType>())
             {
                 return typeType->type;
             }
-            else if (auto errorType = exp->Type->As<ErrorType>())
+            else if (auto errorType = exp->type->As<ErrorType>())
             {
-                return exp->Type.type;
+                return exp->type.type;
             }
             else
             {
@@ -336,9 +336,9 @@ namespace Slang
         // the given generic declaration for the given arguments.
         // The arguments should already be checked against
         // the declaration.
-        RefPtr<ExpressionType> InstantiateGenericType(
+        RefPtr<Type> InstantiateGenericType(
             DeclRef<GenericDecl>						genericDeclRef,
-            List<RefPtr<ExpressionSyntaxNode>> const&	args)
+            List<RefPtr<Expr>> const&	args)
         {
             RefPtr<Substitutions> subst = new Substitutions();
             subst->genericDecl = genericDeclRef.getDecl();
@@ -411,9 +411,9 @@ namespace Slang
         // the name of a non-proper type, and then have the compiler fill
         // in the default values for its type arguments (e.g., a variable
         // given type `Texture2D` will actually have type `Texture2D<float4>`).
-        bool CoerceToProperTypeImpl(TypeExp const& typeExp, RefPtr<ExpressionType>* outProperType)
+        bool CoerceToProperTypeImpl(TypeExp const& typeExp, RefPtr<Type>* outProperType)
         {
-            ExpressionType* type = typeExp.type.Ptr();
+            Type* type = typeExp.type.Ptr();
             if (auto genericDeclRefType = type->As<GenericDeclRefType>())
             {
                 // We are using a reference to a generic declaration as a concrete
@@ -426,7 +426,7 @@ namespace Slang
 
                 auto genericDeclRef = genericDeclRefType->GetDeclRef();
                 EnsureDecl(genericDeclRef.decl);
-                List<RefPtr<ExpressionSyntaxNode>> args;
+                List<RefPtr<Expr>> args;
                 for (RefPtr<Decl> member : genericDeclRef.getDecl()->Members)
                 {
                     if (auto typeParam = member.As<GenericTypeParamDecl>())
@@ -450,7 +450,7 @@ namespace Slang
                     }
                     else if (auto valParam = member.As<GenericValueParamDecl>())
                     {
-                        if (!valParam->Expr)
+                        if (!valParam->initExpr)
                         {
                             if (outProperType)
                             {
@@ -465,7 +465,7 @@ namespace Slang
 
                         // TODO: this is one place where syntax should get cloned!
                         if(outProperType)
-                            args.Add(valParam->Expr);
+                            args.Add(valParam->initExpr);
                     }
                     else
                     {
@@ -521,7 +521,7 @@ namespace Slang
         TypeExp CoerceToUsableType(TypeExp const& typeExp)
         {
             TypeExp result = CoerceToProperType(typeExp);
-            ExpressionType* type = result.type.Ptr();
+            Type* type = result.type.Ptr();
             if (auto basicType = type->As<BasicExpressionType>())
             {
                 // TODO: `void` shouldn't be a basic type, to make this easier to avoid
@@ -545,32 +545,32 @@ namespace Slang
             return CoerceToUsableType(TranslateTypeNode(typeExp));
         }
 
-        RefPtr<ExpressionSyntaxNode> CheckTerm(RefPtr<ExpressionSyntaxNode> term)
+        RefPtr<Expr> CheckTerm(RefPtr<Expr> term)
         {
             if (!term) return nullptr;
             return ExprVisitor::dispatch(term);
         }
 
-        RefPtr<ExpressionSyntaxNode> CreateErrorExpr(ExpressionSyntaxNode* expr)
+        RefPtr<Expr> CreateErrorExpr(Expr* expr)
         {
-            expr->Type = QualType(getSession()->getErrorType());
+            expr->type = QualType(getSession()->getErrorType());
             return expr;
         }
 
-        bool IsErrorExpr(RefPtr<ExpressionSyntaxNode> expr)
+        bool IsErrorExpr(RefPtr<Expr> expr)
         {
             // TODO: we may want other cases here...
 
-            if (auto errorType = expr->Type->As<ErrorType>())
+            if (auto errorType = expr->type->As<ErrorType>())
                 return true;
 
             return false;
         }
 
         // Capture the "base" expression in case this is a member reference
-        RefPtr<ExpressionSyntaxNode> GetBaseExpr(RefPtr<ExpressionSyntaxNode> expr)
+        RefPtr<Expr> GetBaseExpr(RefPtr<Expr> expr)
         {
-            if (auto memberExpr = expr.As<MemberExpressionSyntaxNode>())
+            if (auto memberExpr = expr.As<MemberExpr>())
             {
                 return memberExpr->BaseExpression;
             }
@@ -694,10 +694,10 @@ namespace Slang
 
         // Central engine for implementing implicit coercion logic
         bool TryCoerceImpl(
-            RefPtr<ExpressionType>			toType,		// the target type for conversion
-            RefPtr<ExpressionSyntaxNode>*	outToExpr,	// (optional) a place to stuff the target expression
-            RefPtr<ExpressionType>			fromType,	// the source type for the conversion
-            RefPtr<ExpressionSyntaxNode>	fromExpr,	// the source expression
+            RefPtr<Type>			toType,		// the target type for conversion
+            RefPtr<Expr>*	outToExpr,	// (optional) a place to stuff the target expression
+            RefPtr<Type>			fromType,	// the source type for the conversion
+            RefPtr<Expr>	fromExpr,	// the source expression
             ConversionCost*					outCost)	// (optional) a place to stuff the conversion cost
         {
             // Easy case: the types are equal
@@ -727,12 +727,12 @@ namespace Slang
 
                 // In the case where we need to build a reuslt expression,
                 // we will collect the new arguments here
-                List<RefPtr<ExpressionSyntaxNode>> coercedArgs;
+                List<RefPtr<Expr>> coercedArgs;
 
                 if(auto toDeclRefType = toType->As<DeclRefType>())
                 {
                     auto toTypeDeclRef = toDeclRefType->declRef;
-                    if(auto toStructDeclRef = toTypeDeclRef.As<StructSyntaxNode>())
+                    if(auto toStructDeclRef = toTypeDeclRef.As<StructDecl>())
                     {
                         // Trying to initialize a `struct` type given an initializer list.
                         // We will go through the fields in order and try to match them
@@ -751,13 +751,13 @@ namespace Slang
                             auto arg = fromInitializerListExpr->args[argIndex++];
 
                             // 
-                            RefPtr<ExpressionSyntaxNode> coercedArg;
+                            RefPtr<Expr> coercedArg;
                             ConversionCost argCost;
 
                             bool argResult = TryCoerceImpl(
                                 GetType(fieldDeclRef),
                                 outToExpr ? &coercedArg : nullptr,
-                                arg->Type,
+                                arg->type,
                                 arg,
                                 outCost ? &argCost : nullptr);
 
@@ -785,13 +785,13 @@ namespace Slang
 
                     for(auto& arg : fromInitializerListExpr->args)
                     {
-                        RefPtr<ExpressionSyntaxNode> coercedArg;
+                        RefPtr<Expr> coercedArg;
                         ConversionCost argCost;
 
                         bool argResult = TryCoerceImpl(
                                 toElementType,
                                 outToExpr ? &coercedArg : nullptr,
-                                arg->Type,
+                                arg->type,
                                 arg,
                                 outCost ? &argCost : nullptr);
 
@@ -824,7 +824,7 @@ namespace Slang
                 {
                     auto toInitializerListExpr = new InitializerListExpr();
                     toInitializerListExpr->Position = fromInitializerListExpr->Position;
-                    toInitializerListExpr->Type = QualType(toType);
+                    toInitializerListExpr->type = QualType(toType);
                     toInitializerListExpr->args = coercedArgs;
 
 
@@ -978,8 +978,8 @@ namespace Slang
 
         // Check whether a type coercion is possible
         bool CanCoerce(
-            RefPtr<ExpressionType>			toType,			// the target type for conversion
-            RefPtr<ExpressionType>			fromType,		// the source type for the conversion
+            RefPtr<Type>			toType,			// the target type for conversion
+            RefPtr<Type>			fromType,		// the source type for the conversion
             ConversionCost*					outCost = 0)	// (optional) a place to stuff the conversion cost
         {
             return TryCoerceImpl(
@@ -990,14 +990,14 @@ namespace Slang
                 outCost);
         }
 
-        RefPtr<ExpressionSyntaxNode> CreateImplicitCastExpr(
-            RefPtr<ExpressionType>			toType,
-            RefPtr<ExpressionSyntaxNode>	fromExpr)
+        RefPtr<Expr> CreateImplicitCastExpr(
+            RefPtr<Type>			toType,
+            RefPtr<Expr>	fromExpr)
         {
             // In "rewrite" mode, we will generate a different syntax node
             // to indicate that this type-cast was implicitly generated
             // by the compiler, and shouldn't appear in the output code.
-            RefPtr<TypeCastExpressionSyntaxNode> castExpr;
+            RefPtr<TypeCastExpr> castExpr;
             if (isRewriteMode())
             {
                 castExpr = new HiddenImplicitCastExpr();
@@ -1009,7 +1009,7 @@ namespace Slang
 
             castExpr->Position = fromExpr->Position;
             castExpr->TargetType.type = toType;
-            castExpr->Type = QualType(toType);
+            castExpr->type = QualType(toType);
             castExpr->Expression = fromExpr;
             return castExpr;
         }
@@ -1020,29 +1020,29 @@ namespace Slang
         }
 
         // Perform type coercion, and emit errors if it isn't possible
-        RefPtr<ExpressionSyntaxNode> Coerce(
-            RefPtr<ExpressionType>			toType,
-            RefPtr<ExpressionSyntaxNode>	fromExpr)
+        RefPtr<Expr> Coerce(
+            RefPtr<Type>			toType,
+            RefPtr<Expr>	fromExpr)
         {
             // If semantic checking is being suppressed, then we might see
             // expressions without a type, and we need to ignore them.
-            if( !fromExpr->Type.type )
+            if( !fromExpr->type.type )
             {
                 if(isRewriteMode())
                     return fromExpr;
             }
 
-            RefPtr<ExpressionSyntaxNode> expr;
+            RefPtr<Expr> expr;
             if (!TryCoerceImpl(
                 toType,
                 &expr,
-                fromExpr->Type.Ptr(),
+                fromExpr->type.Ptr(),
                 fromExpr.Ptr(),
                 nullptr))
             {
                 if(!isRewriteMode())
                 {
-                    getSink()->diagnose(fromExpr->Position, Diagnostics::typeMismatch, toType, fromExpr->Type);
+                    getSink()->diagnose(fromExpr->Position, Diagnostics::typeMismatch, toType, fromExpr->type);
                 }
 
                 // Note(tfoley): We don't call `CreateErrorExpr` here, because that would
@@ -1059,7 +1059,7 @@ namespace Slang
         void CheckVarDeclCommon(RefPtr<VarDeclBase> varDecl)
         {
             // Check the type, if one was given
-            TypeExp type = CheckUsableType(varDecl->Type);
+            TypeExp type = CheckUsableType(varDecl->type);
 
             // TODO: Additional validation rules on types should go here,
             // but we need to deal with the fact that some cases might be
@@ -1067,7 +1067,7 @@ namespace Slang
             // but not in othters (e.g., an unsized array field in a struct).
 
             // Check the initializers, if one was given
-            RefPtr<ExpressionSyntaxNode> initExpr = CheckTerm(varDecl->Expr);
+            RefPtr<Expr> initExpr = CheckTerm(varDecl->initExpr);
 
             // If a type was given, ...
             if (type.Ptr())
@@ -1098,8 +1098,8 @@ namespace Slang
                 }
             }
 
-            varDecl->Type = type;
-            varDecl->Expr = initExpr;
+            varDecl->type = type;
+            varDecl->initExpr = initExpr;
         }
 
         void CheckGenericConstraintDecl(GenericTypeConstraintDecl* decl)
@@ -1176,7 +1176,7 @@ namespace Slang
         }
 
         RefPtr<ConstantIntVal> checkConstantIntVal(
-            RefPtr<ExpressionSyntaxNode>    expr)
+            RefPtr<Expr>    expr)
         {
             // First type-check the expression as normal
             expr = CheckExpr(expr);
@@ -1323,7 +1323,7 @@ namespace Slang
             decl->modifiers.first = resultModifiers;
         }
 
-        void visitProgramSyntaxNode(ProgramSyntaxNode* programNode)
+        void visitModuleDecl(ModuleDecl* programNode)
         {
             // Try to register all the builtin decls
             for (auto decl : programNode->Members)
@@ -1355,11 +1355,11 @@ namespace Slang
 
             for (auto & s : programNode->getMembersOfType<TypeDefDecl>())
                 checkDecl(s.Ptr());
-            for (auto & s : programNode->getMembersOfType<StructSyntaxNode>())
+            for (auto & s : programNode->getMembersOfType<StructDecl>())
             {
                 checkDecl(s.Ptr());
             }
-			for (auto & s : programNode->getMembersOfType<ClassSyntaxNode>())
+			for (auto & s : programNode->getMembersOfType<ClassDecl>())
 			{
 				checkDecl(s.Ptr());
 			}
@@ -1370,14 +1370,14 @@ namespace Slang
                 checkDecl(g.Ptr());
             }
 
-            for (auto & func : programNode->getMembersOfType<FunctionSyntaxNode>())
+            for (auto & func : programNode->getMembersOfType<FuncDecl>())
             {
                 if (!func->IsChecked(DeclCheckState::Checked))
                 {
                     VisitFunctionDeclaration(func.Ptr());
                 }
             }
-            for (auto & func : programNode->getMembersOfType<FunctionSyntaxNode>())
+            for (auto & func : programNode->getMembersOfType<FuncDecl>())
             {
                 EnsureDecl(func);
             }
@@ -1400,7 +1400,7 @@ namespace Slang
             }
         }
 
-		void visitClassSyntaxNode(ClassSyntaxNode * classNode)
+		void visitClassDecl(ClassDecl * classNode)
 		{
 			if (classNode->IsChecked(DeclCheckState::Checked))
 				return;
@@ -1408,7 +1408,7 @@ namespace Slang
 
 			for (auto field : classNode->GetFields())
 			{
-				field->Type = CheckUsableType(field->Type);
+				field->type = CheckUsableType(field->type);
 				field->SetCheckState(DeclCheckState::Checked);
 			}
 		}
@@ -1417,11 +1417,11 @@ namespace Slang
         {
             // TODO: bottleneck through general-case variable checking
 
-            field->Type = CheckUsableType(field->Type);
+            field->type = CheckUsableType(field->type);
             field->SetCheckState(DeclCheckState::Checked);
         }
 
-        void visitStructSyntaxNode(StructSyntaxNode * structNode)
+        void visitStructDecl(StructDecl * structNode)
         {
             if (structNode->IsChecked(DeclCheckState::Checked))
                 return;
@@ -1446,17 +1446,17 @@ namespace Slang
             if (decl->IsChecked(DeclCheckState::Checked)) return;
 
             decl->SetCheckState(DeclCheckState::CheckingHeader);
-            decl->Type = CheckProperType(decl->Type);
+            decl->type = CheckProperType(decl->type);
             decl->SetCheckState(DeclCheckState::Checked);
         }
 
-        void checkStmt(StatementSyntaxNode* stmt)
+        void checkStmt(Stmt* stmt)
         {
             if (!stmt) return;
             StmtVisitor::dispatch(stmt);
         }
 
-        void visitFunctionSyntaxNode(FunctionSyntaxNode *functionNode)
+        void visitFuncDecl(FuncDecl *functionNode)
         {
             if (functionNode->IsChecked(DeclCheckState::Checked))
                 return;
@@ -1478,8 +1478,8 @@ namespace Slang
         // Check if two functions have the same signature for the purposes
         // of overload resolution.
         bool DoFunctionSignaturesMatch(
-            FunctionSyntaxNode* fst,
-            FunctionSyntaxNode* snd)
+            FuncDecl* fst,
+            FuncDecl* snd)
         {
             // TODO(tfoley): This function won't do anything sensible for generics,
             // so we need to figure out a plan for that...
@@ -1501,7 +1501,7 @@ namespace Slang
                 auto sndParam = sndParams[ii];
 
                 // If a given parameter type doesn't match, then signatures don't match
-                if (!fstParam->Type.Equals(sndParam->Type))
+                if (!fstParam->type.Equals(sndParam->type))
                     return false;
 
                 // If one parameter is `out` and the other isn't, then they don't match
@@ -1518,7 +1518,7 @@ namespace Slang
             return true;
         }
 
-        void ValidateFunctionRedeclaration(FunctionSyntaxNode* funcDecl)
+        void ValidateFunctionRedeclaration(FuncDecl* funcDecl)
         {
             auto parentDecl = funcDecl->ParentDecl;
             SLANG_RELEASE_ASSERT(parentDecl);
@@ -1538,7 +1538,7 @@ namespace Slang
                 // We only care about previously-declared functions
                 // Note(tfoley): although we should really error out if the
                 // name is already in use for something else, like a variable...
-                auto prevFuncDecl = dynamic_cast<FunctionSyntaxNode*>(prevDecl);
+                auto prevFuncDecl = dynamic_cast<FuncDecl*>(prevDecl);
                 if (!prevFuncDecl)
                     continue;
 
@@ -1592,12 +1592,12 @@ namespace Slang
             // Nothing to do
         }
 
-        void visitParameterSyntaxNode(ParameterSyntaxNode* para)
+        void visitParamDecl(ParamDecl* para)
         {
             // TODO: This needs to bottleneck through the common variable checks
 
-            para->Type = CheckUsableType(para->Type);
-            if (para->Type.Equals(getSession()->getVoidType()))
+            para->type = CheckUsableType(para->type);
+            if (para->type.Equals(getSession()->getVoidType()))
             {
                 if (!isRewriteMode())
                 {
@@ -1606,7 +1606,7 @@ namespace Slang
             }
         }
 
-        void VisitFunctionDeclaration(FunctionSyntaxNode *functionNode)
+        void VisitFunctionDeclaration(FuncDecl *functionNode)
         {
             if (functionNode->IsChecked(DeclCheckState::CheckedHeader)) return;
             functionNode->SetCheckState(DeclCheckState::CheckingHeader);
@@ -1636,7 +1636,7 @@ namespace Slang
             ValidateFunctionRedeclaration(functionNode);
         }
 
-        void visitVarDeclrStatementSyntaxNode(VarDeclrStatementSyntaxNode* stmt)
+        void visitDeclStmt(DeclStmt* stmt)
         {
             // We directly dispatch here instead of using `EnsureDecl()` for two
             // reasons:
@@ -1677,7 +1677,7 @@ namespace Slang
             return nullptr;
         }
 
-        void visitBreakStatementSyntaxNode(BreakStatementSyntaxNode *stmt)
+        void visitBreakStmt(BreakStmt *stmt)
         {
             auto outer = FindOuterStmt<BreakableStmt>();
             if (!outer)
@@ -1689,7 +1689,7 @@ namespace Slang
             }
             stmt->parentStmt = outer;
         }
-        void visitContinueStatementSyntaxNode(ContinueStatementSyntaxNode *stmt)
+        void visitContinueStmt(ContinueStmt *stmt)
         {
             auto outer = FindOuterStmt<LoopStmt>();
             if (!outer)
@@ -1702,25 +1702,25 @@ namespace Slang
             stmt->parentStmt = outer;
         }
 
-        void PushOuterStmt(StatementSyntaxNode* stmt)
+        void PushOuterStmt(Stmt* stmt)
         {
             outerStmts.Add(stmt);
         }
 
-        void PopOuterStmt(StatementSyntaxNode* /*stmt*/)
+        void PopOuterStmt(Stmt* /*stmt*/)
         {
             outerStmts.RemoveAt(outerStmts.Count() - 1);
         }
 
-        RefPtr<ExpressionSyntaxNode> checkPredicateExpr(ExpressionSyntaxNode* expr)
+        RefPtr<Expr> checkPredicateExpr(Expr* expr)
         {
-            RefPtr<ExpressionSyntaxNode> e = expr;
+            RefPtr<Expr> e = expr;
             e = CheckTerm(e);
             e = Coerce(getSession()->getBoolType(), e);
             return e;
         }
 
-        void visitDoWhileStatementSyntaxNode(DoWhileStatementSyntaxNode *stmt)
+        void visitDoWhileStmt(DoWhileStmt *stmt)
         {
             PushOuterStmt(stmt);
             stmt->Predicate = checkPredicateExpr(stmt->Predicate);
@@ -1728,7 +1728,7 @@ namespace Slang
 
             PopOuterStmt(stmt);
         }
-        void visitForStatementSyntaxNode(ForStatementSyntaxNode *stmt)
+        void visitForStmt(ForStmt *stmt)
         {
             PushOuterStmt(stmt);
             checkStmt(stmt->InitialStatement);
@@ -1745,7 +1745,7 @@ namespace Slang
             PopOuterStmt(stmt);
         }
 
-        RefPtr<ExpressionSyntaxNode> checkExpressionAndExpectIntegerConstant(RefPtr<ExpressionSyntaxNode> expr, RefPtr<IntVal>* outIntVal)
+        RefPtr<Expr> checkExpressionAndExpectIntegerConstant(RefPtr<Expr> expr, RefPtr<IntVal>* outIntVal)
         {
             expr = CheckExpr(expr);
             auto intVal = CheckIntegerConstantExpression(expr);
@@ -1758,7 +1758,7 @@ namespace Slang
         {
             PushOuterStmt(stmt);
 
-            stmt->varDecl->Type.type = getSession()->getIntType();
+            stmt->varDecl->type.type = getSession()->getIntType();
             addModifier(stmt->varDecl, new ConstModifier());
 
             RefPtr<IntVal> rangeBeginVal;
@@ -1834,7 +1834,7 @@ namespace Slang
             }
             stmt->parentStmt = switchStmt;
         }
-        void visitIfStatementSyntaxNode(IfStatementSyntaxNode *stmt)
+        void visitIfStmt(IfStmt *stmt)
         {
             stmt->Predicate = checkPredicateExpr(stmt->Predicate);
             checkStmt(stmt->PositiveStatement);
@@ -1846,17 +1846,17 @@ namespace Slang
             // Nothing to do
         }
 
-        void visitEmptyStatementSyntaxNode(EmptyStatementSyntaxNode*)
+        void visitEmptyStmt(EmptyStmt*)
         {
             // Nothing to do
         }
 
-        void visitDiscardStatementSyntaxNode(DiscardStatementSyntaxNode*)
+        void visitDiscardStmt(DiscardStmt*)
         {
             // Nothing to do
         }
 
-        void visitReturnStatementSyntaxNode(ReturnStatementSyntaxNode *stmt)
+        void visitReturnStmt(ReturnStmt *stmt)
         {
             if (!stmt->Expression)
             {
@@ -1871,7 +1871,7 @@ namespace Slang
             else
             {
                 stmt->Expression = CheckTerm(stmt->Expression);
-                if (!stmt->Expression->Type->Equals(getSession()->getErrorType()))
+                if (!stmt->Expression->type->Equals(getSession()->getErrorType()))
                 {
                     if (function)
                     {
@@ -1901,7 +1901,7 @@ namespace Slang
         void maybeInferArraySizeForVariable(Variable* varDecl)
         {
             // Not an array?
-            auto arrayType = varDecl->Type->AsArrayType();
+            auto arrayType = varDecl->type->AsArrayType();
             if (!arrayType) return;
 
             // Explicit element count given?
@@ -1909,7 +1909,7 @@ namespace Slang
             if (elementCount) return;
 
             // No initializer?
-            auto initExpr = varDecl->Expr;
+            auto initExpr = varDecl->initExpr;
             if(!initExpr) return;
 
             // Is the initializer an initializer list?
@@ -1919,7 +1919,7 @@ namespace Slang
                 elementCount = new ConstantIntVal(argCount);
             }
             // Is the type of the initializer an array type?
-            else if(auto arrayInitType = initExpr->Type->As<ArrayExpressionType>())
+            else if(auto arrayInitType = initExpr->type->As<ArrayExpressionType>())
             {
                 elementCount = arrayInitType->ArrayLength;
             }
@@ -1931,14 +1931,14 @@ namespace Slang
 
             // Create a new array type based on the size we found,
             // and install it into our type.
-            varDecl->Type.type = getArrayType(
+            varDecl->type.type = getArrayType(
                 arrayType->BaseType,
                 elementCount);
         }
 
         void ValidateArraySizeForVariable(Variable* varDecl)
         {
-            auto arrayType = varDecl->Type->AsArrayType();
+            auto arrayType = varDecl->type->AsArrayType();
             if (!arrayType) return;
 
             auto elementCount = arrayType->ArrayLength;
@@ -1966,7 +1966,7 @@ namespace Slang
 
         void visitVariable(Variable* varDecl)
         {
-            TypeExp typeExp = CheckUsableType(varDecl->Type);
+            TypeExp typeExp = CheckUsableType(varDecl->type);
 #if 0
             if (typeExp.type->GetBindableResourceType() != BindableResourceType::NonBindable)
             {
@@ -1974,12 +1974,12 @@ namespace Slang
                 auto parentDecl = varDecl->ParentDecl;
                 if (auto parentScopeDecl = dynamic_cast<ScopeDecl*>(parentDecl))
                 {
-                    getSink()->diagnose(varDecl->Type, Diagnostics::invalidTypeForLocalVariable);
+                    getSink()->diagnose(varDecl->type, Diagnostics::invalidTypeForLocalVariable);
                 }
             }
 #endif
-            varDecl->Type = typeExp;
-            if (varDecl->Type.Equals(getSession()->getVoidType()))
+            varDecl->type = typeExp;
+            if (varDecl->type.Equals(getSession()->getVoidType()))
             {
                 if (!isRewriteMode())
                 {
@@ -1987,10 +1987,10 @@ namespace Slang
                 }
             }
 
-            if(auto initExpr = varDecl->Expr)
+            if(auto initExpr = varDecl->initExpr)
             {
                 initExpr = CheckTerm(initExpr);
-                varDecl->Expr = initExpr;
+                varDecl->initExpr = initExpr;
             }
 
             // If this is an array variable, then we first want to give
@@ -2007,63 +2007,63 @@ namespace Slang
             ValidateArraySizeForVariable(varDecl);
 
 
-            if(auto initExpr = varDecl->Expr)
+            if(auto initExpr = varDecl->initExpr)
             {
                 // TODO(tfoley): should coercion of initializer lists be special-cased
                 // here, or handled as a general case for coercion?
 
-                initExpr = Coerce(varDecl->Type.Ptr(), initExpr);
-                varDecl->Expr = initExpr;
+                initExpr = Coerce(varDecl->type.Ptr(), initExpr);
+                varDecl->initExpr = initExpr;
             }
 
             varDecl->SetCheckState(DeclCheckState::Checked);
         }
 
-        void visitWhileStatementSyntaxNode(WhileStatementSyntaxNode *stmt)
+        void visitWhileStmt(WhileStmt *stmt)
         {
             PushOuterStmt(stmt);
             stmt->Predicate = checkPredicateExpr(stmt->Predicate);
             checkStmt(stmt->Statement);
             PopOuterStmt(stmt);
         }
-        void visitExpressionStatementSyntaxNode(ExpressionStatementSyntaxNode *stmt)
+        void visitExpressionStmt(ExpressionStmt *stmt)
         {
             stmt->Expression = CheckExpr(stmt->Expression);
         }
 
-        RefPtr<ExpressionSyntaxNode> visitConstantExpressionSyntaxNode(ConstantExpressionSyntaxNode *expr)
+        RefPtr<Expr> visitConstantExpr(ConstantExpr *expr)
         {
             // The expression might already have a type, determined by its suffix
-            if(expr->Type.type)
+            if(expr->type.type)
                 return expr;
 
             switch (expr->ConstType)
             {
-            case ConstantExpressionSyntaxNode::ConstantType::Int:
-                expr->Type = getSession()->getIntType();
+            case ConstantExpr::ConstantType::Int:
+                expr->type = getSession()->getIntType();
                 break;
-            case ConstantExpressionSyntaxNode::ConstantType::Bool:
-                expr->Type = getSession()->getBoolType();
+            case ConstantExpr::ConstantType::Bool:
+                expr->type = getSession()->getBoolType();
                 break;
-            case ConstantExpressionSyntaxNode::ConstantType::Float:
-                expr->Type = getSession()->getFloatType();
+            case ConstantExpr::ConstantType::Float:
+                expr->type = getSession()->getFloatType();
                 break;
             default:
-                expr->Type = QualType(getSession()->getErrorType());
+                expr->type = QualType(getSession()->getErrorType());
                 throw "Invalid constant type.";
                 break;
             }
             return expr;
         }
 
-        IntVal* GetIntVal(ConstantExpressionSyntaxNode* expr)
+        IntVal* GetIntVal(ConstantExpr* expr)
         {
             // TODO(tfoley): don't keep allocating here!
             return new ConstantIntVal(expr->integerValue);
         }
 
         RefPtr<IntVal> TryConstantFoldExpr(
-            InvokeExpressionSyntaxNode* invokeExpr)
+            InvokeExpr* invokeExpr)
         {
             // We need all the operands to the expression
 
@@ -2174,7 +2174,7 @@ namespace Slang
         }
 
         RefPtr<IntVal> TryConstantFoldExpr(
-            ExpressionSyntaxNode* expr)
+            Expr* expr)
         {
             // Unwrap any "identity" expressions
             while (auto parenExpr = dynamic_cast<ParenExpr*>(expr))
@@ -2183,7 +2183,7 @@ namespace Slang
             }
 
             // TODO(tfoley): more serious constant folding here
-            if (auto constExp = dynamic_cast<ConstantExpressionSyntaxNode*>(expr))
+            if (auto constExp = dynamic_cast<ConstantExpr*>(expr))
             {
                 return GetIntVal(constExp);
             }
@@ -2259,13 +2259,13 @@ namespace Slang
                 }
             }
 
-            if (auto invokeExpr = dynamic_cast<InvokeExpressionSyntaxNode*>(expr))
+            if (auto invokeExpr = dynamic_cast<InvokeExpr*>(expr))
             {
                 auto val = TryConstantFoldExpr(invokeExpr);
                 if (val)
                     return val;
             }
-            else if(auto castExpr = dynamic_cast<TypeCastExpressionSyntaxNode*>(expr))
+            else if(auto castExpr = dynamic_cast<TypeCastExpr*>(expr))
             {
                 auto val = TryConstantFoldExpr(castExpr->Expression.Ptr());
                 if(val)
@@ -2277,9 +2277,9 @@ namespace Slang
 
         // Try to check an integer constant expression, either returning the value,
         // or NULL if the expression isn't recognized as a constant.
-        RefPtr<IntVal> TryCheckIntegerConstantExpression(ExpressionSyntaxNode* exp)
+        RefPtr<IntVal> TryCheckIntegerConstantExpression(Expr* exp)
         {
-            if (!exp->Type.type->Equals(getSession()->getIntType()))
+            if (!exp->type.type->Equals(getSession()->getIntType()))
             {
                 return nullptr;
             }
@@ -2291,7 +2291,7 @@ namespace Slang
         }
 
         // Enforce that an expression resolves to an integer constant, and get its value
-        RefPtr<IntVal> CheckIntegerConstantExpression(ExpressionSyntaxNode* inExpr)
+        RefPtr<IntVal> CheckIntegerConstantExpression(Expr* inExpr)
         {
             // First coerce the expression to the expected type
             auto expr = Coerce(getSession()->getIntType(),inExpr);
@@ -2308,15 +2308,15 @@ namespace Slang
 
 
 
-        RefPtr<ExpressionSyntaxNode> CheckSimpleSubscriptExpr(
-            RefPtr<IndexExpressionSyntaxNode>   subscriptExpr,
-            RefPtr<ExpressionType>              elementType)
+        RefPtr<Expr> CheckSimpleSubscriptExpr(
+            RefPtr<IndexExpr>   subscriptExpr,
+            RefPtr<Type>              elementType)
         {
             auto baseExpr = subscriptExpr->BaseExpression;
             auto indexExpr = subscriptExpr->IndexExpression;
 
-            if (!indexExpr->Type->Equals(getSession()->getIntType()) &&
-                !indexExpr->Type->Equals(getSession()->getUIntType()))
+            if (!indexExpr->type->Equals(getSession()->getIntType()) &&
+                !indexExpr->type->Equals(getSession()->getUIntType()))
             {
                 if (!isRewriteMode())
                 {
@@ -2325,10 +2325,10 @@ namespace Slang
                 return CreateErrorExpr(subscriptExpr.Ptr());
             }
 
-            subscriptExpr->Type = QualType(elementType);
+            subscriptExpr->type = QualType(elementType);
 
             // TODO(tfoley): need to be more careful about this stuff
-            subscriptExpr->Type.IsLeftValue = baseExpr->Type.IsLeftValue;
+            subscriptExpr->type.IsLeftValue = baseExpr->type.IsLeftValue;
 
             return subscriptExpr;
         }
@@ -2344,7 +2344,7 @@ namespace Slang
         // programmatically, so that it will work just like a type of
         // that form constructed by the user.
         RefPtr<VectorExpressionType> createVectorType(
-            RefPtr<ExpressionType>  elementType,
+            RefPtr<Type>  elementType,
             RefPtr<IntVal>          elementCount)
         {
             auto session = getSession();
@@ -2364,12 +2364,12 @@ namespace Slang
                 declRef)->As<VectorExpressionType>();
         }
 
-        RefPtr<ExpressionSyntaxNode> visitIndexExpressionSyntaxNode(IndexExpressionSyntaxNode* subscriptExpr)
+        RefPtr<Expr> visitIndexExpr(IndexExpr* subscriptExpr)
         {
             auto baseExpr = subscriptExpr->BaseExpression;
             baseExpr = CheckExpr(baseExpr);
 
-            RefPtr<ExpressionSyntaxNode> indexExpr = subscriptExpr->IndexExpression;
+            RefPtr<Expr> indexExpr = subscriptExpr->IndexExpression;
             if (indexExpr)
             {
                 indexExpr = CheckExpr(indexExpr);
@@ -2385,7 +2385,7 @@ namespace Slang
 
             // Otherwise, we need to look at the type of the base expression,
             // to figure out how subscripting should work.
-            auto baseType = baseExpr->Type.Ptr();
+            auto baseType = baseExpr->type.Ptr();
             if (auto baseTypeType = baseType->As<TypeType>())
             {
                 // We are trying to "index" into a type, so we have an expression like `float[2]`
@@ -2403,7 +2403,7 @@ namespace Slang
                     elementCount);
 
                 typeResult = arrayType;
-                subscriptExpr->Type = QualType(getTypeType(arrayType));
+                subscriptExpr->type = QualType(getTypeType(arrayType));
                 return subscriptExpr;
             }
             else if (auto baseArrayType = baseType->As<ArrayExpressionType>())
@@ -2451,13 +2451,13 @@ namespace Slang
                         goto fail;
                     }
 
-                    RefPtr<ExpressionSyntaxNode> subscriptFuncExpr = createLookupResultExpr(
+                    RefPtr<Expr> subscriptFuncExpr = createLookupResultExpr(
                         lookupResult, subscriptExpr->BaseExpression, subscriptExpr);
 
                     // Now that we know there is at least one subscript member,
                     // we will construct a reference to it and try to call it
 
-                    RefPtr<InvokeExpressionSyntaxNode> subscriptCallExpr = new InvokeExpressionSyntaxNode();
+                    RefPtr<InvokeExpr> subscriptCallExpr = new InvokeExpr();
                     subscriptCallExpr->Position = subscriptExpr->Position;
                     subscriptCallExpr->FunctionExpr = subscriptFuncExpr;
 
@@ -2478,14 +2478,14 @@ namespace Slang
             }
         }
 
-        bool MatchArguments(FunctionSyntaxNode * functionNode, List <RefPtr<ExpressionSyntaxNode>> &args)
+        bool MatchArguments(FuncDecl * functionNode, List <RefPtr<Expr>> &args)
         {
             if (functionNode->GetParameters().Count() != args.Count())
                 return false;
             int i = 0;
             for (auto param : functionNode->GetParameters())
             {
-                if (!param->Type.Equals(args[i]->Type.Ptr()))
+                if (!param->type.Equals(args[i]->type.Ptr()))
                     return false;
                 i++;
             }
@@ -2493,31 +2493,31 @@ namespace Slang
         }
 
         // Coerce an expression to a specific  type that it is expected to have in context
-        RefPtr<ExpressionSyntaxNode> CoerceExprToType(
-            RefPtr<ExpressionSyntaxNode>	expr,
-            RefPtr<ExpressionType>			type)
+        RefPtr<Expr> CoerceExprToType(
+            RefPtr<Expr>	expr,
+            RefPtr<Type>			type)
         {
             // TODO(tfoley): clean this up so there is only one version...
             return Coerce(type, expr);
         }
 
-        RefPtr<ExpressionSyntaxNode> visitParenExpr(ParenExpr* expr)
+        RefPtr<Expr> visitParenExpr(ParenExpr* expr)
         {
             auto base = expr->base;
             base = CheckTerm(base);
 
             expr->base = base;
-            expr->Type = base->Type;
+            expr->type = base->type;
             return expr;
         }
 
         //
 
-        RefPtr<ExpressionSyntaxNode> visitAssignExpr(AssignExpr* expr)
+        RefPtr<Expr> visitAssignExpr(AssignExpr* expr)
         {
             expr->left = CheckExpr(expr->left);
 
-            auto type = expr->left->Type;
+            auto type = expr->left->type;
 
             expr->right = Coerce(type, CheckTerm(expr->right));
 
@@ -2532,7 +2532,7 @@ namespace Slang
                     getSink()->diagnose(expr, Diagnostics::assignNonLValue);
                 }
             }
-            expr->Type = type;
+            expr->type = type;
             return expr;
         }
 
@@ -2595,7 +2595,7 @@ namespace Slang
 
             for (auto& paramDecl : decl->GetParameters())
             {
-                paramDecl->Type = CheckUsableType(paramDecl->Type);
+                paramDecl->type = CheckUsableType(paramDecl->type);
             }
             decl->SetCheckState(DeclCheckState::CheckedHeader);
 
@@ -2611,7 +2611,7 @@ namespace Slang
 
             for (auto& paramDecl : decl->GetParameters())
             {
-                paramDecl->Type = CheckUsableType(paramDecl->Type);
+                paramDecl->type = CheckUsableType(paramDecl->type);
             }
 
             decl->ReturnType = CheckUsableType(decl->ReturnType);
@@ -2645,7 +2645,7 @@ namespace Slang
             List<Constraint> constraints;
         };
 
-        RefPtr<ExpressionType> TryJoinVectorAndScalarType(
+        RefPtr<Type> TryJoinVectorAndScalarType(
             RefPtr<VectorExpressionType> vectorType,
             RefPtr<BasicExpressionType>  scalarType)
         {
@@ -2665,7 +2665,7 @@ namespace Slang
         }
 
         bool DoesTypeConformToInterface(
-            RefPtr<ExpressionType>  type,
+            RefPtr<Type>  type,
             DeclRef<InterfaceDecl>        interfaceDeclRef)
         {
             // for now look up a conformance member...
@@ -2691,8 +2691,8 @@ namespace Slang
             return false;
         }
 
-        RefPtr<ExpressionType> TryJoinTypeWithInterface(
-            RefPtr<ExpressionType>  type,
+        RefPtr<Type> TryJoinTypeWithInterface(
+            RefPtr<Type>  type,
             DeclRef<InterfaceDecl>        interfaceDeclRef)
         {
             // The most basic test here should be: does the type declare conformance to the trait.
@@ -2710,9 +2710,9 @@ namespace Slang
         }
 
         // Try to compute the "join" between two types
-        RefPtr<ExpressionType> TryJoinTypes(
-            RefPtr<ExpressionType>  left,
-            RefPtr<ExpressionType>  right)
+        RefPtr<Type> TryJoinTypes(
+            RefPtr<Type>  left,
+            RefPtr<Type>  right)
         {
             // Easy case: they are the same type!
             if (left->Equals(right))
@@ -2828,13 +2828,13 @@ namespace Slang
             {
                 if (auto typeParam = m.As<GenericTypeParamDecl>())
                 {
-                    RefPtr<ExpressionType> type = nullptr;
+                    RefPtr<Type> type = nullptr;
                     for (auto& c : system->constraints)
                     {
                         if (c.decl != typeParam.getDecl())
                             continue;
 
-                        auto cType = c.val.As<ExpressionType>();
+                        auto cType = c.val.As<Type>();
                         SLANG_RELEASE_ASSERT(cType.Ptr());
 
                         if (!type)
@@ -2952,7 +2952,7 @@ namespace Slang
             LookupResultItem item;
 
             // The type of the result expression if this candidate is selected
-            RefPtr<ExpressionType>	resultType;
+            RefPtr<Type>	resultType;
 
             // A system for tracking constraints introduced on generic parameters
             ConstraintSystem constraintSystem;
@@ -2978,7 +2978,7 @@ namespace Slang
             };
 
             RefPtr<AppExprBase> appExpr;
-            RefPtr<ExpressionSyntaxNode> baseExpr;
+            RefPtr<Expr> baseExpr;
 
             // Are we still trying out candidates, or are we
             // checking the chosen one for real?
@@ -3000,7 +3000,7 @@ namespace Slang
         };
 
         // count the number of parameters required/allowed for a callable
-        ParamCounts CountParameters(FilteredMemberRefList<ParameterSyntaxNode> params)
+        ParamCounts CountParameters(FilteredMemberRefList<ParamDecl> params)
         {
             ParamCounts counts = { 0, 0 };
             for (auto param : params)
@@ -3017,7 +3017,7 @@ namespace Slang
                 // 2. We are not handling the possibility of multiple declarations for
                 //    a single function, where we'd need to merge default parameters across
                 //    all the declarations.
-                if (!param.getDecl()->Expr)
+                if (!param.getDecl()->initExpr)
                 {
                     counts.required++;
                 }
@@ -3042,7 +3042,7 @@ namespace Slang
                 else if (auto valParam = m.As<GenericValueParamDecl>())
                 {
                     counts.allowed++;
-                    if (!valParam->Expr)
+                    if (!valParam->initExpr)
                     {
                         counts.required++;
                     }
@@ -3180,7 +3180,7 @@ namespace Slang
                     if (context.mode == OverloadResolveContext::Mode::JustTrying)
                     {
                         ConversionCost cost = kConversionCost_None;
-                        if (!CanCoerce(GetType(valParamRef), arg->Type, &cost))
+                        if (!CanCoerce(GetType(valParamRef), arg->type, &cost))
                         {
                             return false;
                         }
@@ -3208,7 +3208,7 @@ namespace Slang
             auto& args = context.appExpr->Arguments;
             UInt argCount = args.Count();
 
-            List<DeclRef<ParameterSyntaxNode>> params;
+            List<DeclRef<ParamDecl>> params;
             switch (candidate.flavor)
             {
             case OverloadCandidate::Flavor::Func:
@@ -3235,7 +3235,7 @@ namespace Slang
                 if (context.mode == OverloadResolveContext::Mode::JustTrying)
                 {
                     ConversionCost cost = kConversionCost_None;
-                    if (!CanCoerce(GetType(param), arg->Type, &cost))
+                    if (!CanCoerce(GetType(param), arg->type, &cost))
                     {
                         return false;
                     }
@@ -3282,8 +3282,8 @@ namespace Slang
         }
 
         // Create the representation of a given generic applied to some arguments
-        RefPtr<ExpressionSyntaxNode> CreateGenericDeclRef(
-            RefPtr<ExpressionSyntaxNode>	baseExpr,
+        RefPtr<Expr> CreateGenericDeclRef(
+            RefPtr<Expr>	baseExpr,
             RefPtr<AppExprBase>				appExpr)
         {
             auto baseDeclRefExpr = baseExpr.As<DeclRefExpr>();
@@ -3322,7 +3322,7 @@ namespace Slang
         //
         // If the candidate isn't actually applicable, this is
         // where we'd start reporting the issue(s).
-        RefPtr<ExpressionSyntaxNode> CompleteOverloadCandidate(
+        RefPtr<Expr> CompleteOverloadCandidate(
             OverloadResolveContext&		context,
             OverloadCandidate&			candidate)
         {
@@ -3344,7 +3344,7 @@ namespace Slang
             }
 
             context.mode = OverloadResolveContext::Mode::ForReal;
-            context.appExpr->Type = QualType(getSession()->getErrorType());
+            context.appExpr->type = QualType(getSession()->getErrorType());
 
             if (!TryCheckOverloadCandidateArity(context, candidate))
                 goto error;
@@ -3366,14 +3366,14 @@ namespace Slang
                 {
                 case OverloadCandidate::Flavor::Func:
                     context.appExpr->FunctionExpr = baseExpr;
-                    context.appExpr->Type = QualType(candidate.resultType);
+                    context.appExpr->type = QualType(candidate.resultType);
 
                     // A call may yield an l-value, and we should take a look at the candidate to be sure
                     if(auto subscriptDeclRef = candidate.item.declRef.As<SubscriptDecl>())
                     {
                         for(auto setter : subscriptDeclRef.getDecl()->getMembersOfType<SetterDecl>())
                         {
-                            context.appExpr->Type.IsLeftValue = true;
+                            context.appExpr->type.IsLeftValue = true;
                         }
                     }
 
@@ -3550,7 +3550,7 @@ namespace Slang
 
         void AddCtorOverloadCandidate(
             LookupResultItem		typeItem,
-            RefPtr<ExpressionType>	type,
+            RefPtr<Type>	type,
             DeclRef<ConstructorDecl>		ctorDeclRef,
             OverloadResolveContext&	context)
         {
@@ -3590,9 +3590,9 @@ namespace Slang
             RefPtr<Val>			snd)
         {
             // if both values are types, then unify types
-            if (auto fstType = fst.As<ExpressionType>())
+            if (auto fstType = fst.As<Type>())
             {
-                if (auto sndType = snd.As<ExpressionType>())
+                if (auto sndType = snd.As<Type>())
                 {
                     return TryUnifyTypes(constraints, fstType, sndType);
                 }
@@ -3663,7 +3663,7 @@ namespace Slang
         bool TryUnifyTypeParam(
             ConstraintSystem&				constraints,
             RefPtr<GenericTypeParamDecl>	typeParamDecl,
-            RefPtr<ExpressionType>			type)
+            RefPtr<Type>			type)
         {
             // We want to constrain the given type parameter
             // to equal the given type.
@@ -3708,8 +3708,8 @@ namespace Slang
 
         bool TryUnifyTypesByStructuralMatch(
             ConstraintSystem&       constraints,
-            RefPtr<ExpressionType>  fst,
-            RefPtr<ExpressionType>  snd)
+            RefPtr<Type>  fst,
+            RefPtr<Type>  snd)
         {
             if (auto fstDeclRefType = fst->As<DeclRefType>())
             {
@@ -3747,8 +3747,8 @@ namespace Slang
 
         bool TryUnifyTypes(
             ConstraintSystem&       constraints,
-            RefPtr<ExpressionType>  fst,
-            RefPtr<ExpressionType>  snd)
+            RefPtr<Type>  fst,
+            RefPtr<Type>  snd)
         {
             if (fst->Equals(snd)) return true;
 
@@ -3819,7 +3819,7 @@ namespace Slang
         // Is the candidate extension declaration actually applicable to the given type
         DeclRef<ExtensionDecl> ApplyExtensionToType(
             ExtensionDecl*			extDecl,
-            RefPtr<ExpressionType>	type)
+            RefPtr<Type>	type)
         {
             if (auto extGenericDecl = GetOuterGeneric(extDecl))
             {
@@ -3856,13 +3856,13 @@ namespace Slang
 
         bool TryUnifyArgAndParamTypes(
             ConstraintSystem&				system,
-            RefPtr<ExpressionSyntaxNode>	argExpr,
-            DeclRef<ParameterSyntaxNode>					paramDeclRef)
+            RefPtr<Expr>	argExpr,
+            DeclRef<ParamDecl>					paramDeclRef)
         {
             // TODO(tfoley): potentially need a bit more
             // nuance in case where argument might be
             // an overload group...
-            return TryUnifyTypes(system, argExpr->Type, GetType(paramDeclRef));
+            return TryUnifyTypes(system, argExpr->type, GetType(paramDeclRef));
         }
 
         // Take a generic declaration and try to specialize its parameters
@@ -3945,7 +3945,7 @@ namespace Slang
 
         void AddAggTypeOverloadCandidates(
             LookupResultItem		typeItem,
-            RefPtr<ExpressionType>	type,
+            RefPtr<Type>	type,
             DeclRef<AggTypeDecl>			aggTypeDeclRef,
             OverloadResolveContext&	context)
         {
@@ -3990,7 +3990,7 @@ namespace Slang
         }
 
         void AddTypeOverloadCandidates(
-            RefPtr<ExpressionType>	type,
+            RefPtr<Type>	type,
             OverloadResolveContext&	context)
         {
             if (auto declRefType = type->As<DeclRefType>())
@@ -4059,10 +4059,10 @@ namespace Slang
         }
 
         void AddOverloadCandidates(
-            RefPtr<ExpressionSyntaxNode>	funcExpr,
+            RefPtr<Expr>	funcExpr,
             OverloadResolveContext&			context)
         {
-            auto funcExprType = funcExpr->Type;
+            auto funcExprType = funcExpr->type;
 
             if (auto funcDeclRefExpr = funcExpr.As<DeclRefExpr>())
             {
@@ -4096,7 +4096,7 @@ namespace Slang
             }
         }
 
-        void formatType(StringBuilder& sb, RefPtr<ExpressionType> type)
+        void formatType(StringBuilder& sb, RefPtr<Type> type)
         {
             sb << type->ToString();
         }
@@ -4228,7 +4228,7 @@ namespace Slang
             for (auto a : expr->Arguments)
             {
                 if (!first) argsListBuilder << ", ";
-                argsListBuilder << a->Type->ToString();
+                argsListBuilder << a->type->ToString();
                 first = false;
             }
             argsListBuilder << ")";
@@ -4236,11 +4236,11 @@ namespace Slang
         }
 
 
-        RefPtr<ExpressionSyntaxNode> ResolveInvoke(InvokeExpressionSyntaxNode * expr)
+        RefPtr<Expr> ResolveInvoke(InvokeExpr * expr)
         {
             // Look at the base expression for the call, and figure out how to invoke it.
             auto funcExpr = expr->FunctionExpr;
-            auto funcExprType = funcExpr->Type;
+            auto funcExprType = funcExpr->type;
 
             // If we are trying to apply an erroroneous expression, then just bail out now.
             if(IsErrorExpr(funcExpr))
@@ -4258,7 +4258,7 @@ namespace Slang
 
             OverloadResolveContext context;
             context.appExpr = expr;
-            if (auto funcMemberExpr = funcExpr.As<MemberExpressionSyntaxNode>())
+            if (auto funcMemberExpr = funcExpr.As<MemberExpr>())
             {
                 context.baseExpr = funcMemberExpr->BaseExpression;
             }
@@ -4287,9 +4287,9 @@ namespace Slang
                 }
 
                 String funcName;
-                if (auto baseVar = funcExpr.As<VarExpressionSyntaxNode>())
+                if (auto baseVar = funcExpr.As<VarExpr>())
                     funcName = baseVar->name;
-                else if(auto baseMemberRef = funcExpr.As<MemberExpressionSyntaxNode>())
+                else if(auto baseMemberRef = funcExpr.As<MemberExpr>())
                     funcName = baseMemberRef->name;
 
                 String argsList = GetCallSignatureString(expr);
@@ -4373,7 +4373,7 @@ namespace Slang
                 {
                     getSink()->diagnose(expr->FunctionExpr, Diagnostics::expectedFunction);
                 }
-                expr->Type = QualType(getSession()->getErrorType());
+                expr->type = QualType(getSession()->getErrorType());
                 return expr;
             }
         }
@@ -4396,7 +4396,7 @@ namespace Slang
         }
 
         void AddGenericOverloadCandidates(
-            RefPtr<ExpressionSyntaxNode>	baseExpr,
+            RefPtr<Expr>	baseExpr,
             OverloadResolveContext&			context)
         {
             if(auto baseDeclRefExpr = baseExpr.As<DeclRefExpr>())
@@ -4419,7 +4419,7 @@ namespace Slang
             }
         }
 
-        RefPtr<ExpressionSyntaxNode> visitGenericAppExpr(GenericAppExpr * genericAppExpr)
+        RefPtr<Expr> 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
@@ -4509,12 +4509,12 @@ namespace Slang
             }
         }
 
-        RefPtr<ExpressionSyntaxNode> visitSharedTypeExpr(SharedTypeExpr* expr)
+        RefPtr<Expr> visitSharedTypeExpr(SharedTypeExpr* expr)
         {
-            if (!expr->Type.Ptr())
+            if (!expr->type.Ptr())
             {
                 expr->base = CheckProperType(expr->base);
-                expr->Type = expr->base.exp->Type;
+                expr->type = expr->base.exp->type;
             }
             return expr;
         }
@@ -4522,7 +4522,7 @@ namespace Slang
 
 
 
-        RefPtr<ExpressionSyntaxNode> CheckExpr(RefPtr<ExpressionSyntaxNode> expr)
+        RefPtr<Expr> CheckExpr(RefPtr<Expr> expr)
         {
             auto term = CheckTerm(expr);
 
@@ -4532,17 +4532,17 @@ namespace Slang
             return term;
         }
 
-        RefPtr<ExpressionSyntaxNode> CheckInvokeExprWithCheckedOperands(InvokeExpressionSyntaxNode *expr)
+        RefPtr<Expr> CheckInvokeExprWithCheckedOperands(InvokeExpr *expr)
         {
 
             auto rs = ResolveInvoke(expr);
-            if (auto invoke = dynamic_cast<InvokeExpressionSyntaxNode*>(rs.Ptr()))
+            if (auto invoke = dynamic_cast<InvokeExpr*>(rs.Ptr()))
             {
                 // if this is still an invoke expression, test arguments passed to inout/out parameter are LValues
-                if(auto funcType = invoke->FunctionExpr->Type->As<FuncType>())
+                if(auto funcType = invoke->FunctionExpr->type->As<FuncType>())
                 {
-                    List<RefPtr<ParameterSyntaxNode>> paramsStorage;
-                    List<RefPtr<ParameterSyntaxNode>> * params = nullptr;
+                    List<RefPtr<ParamDecl>> paramsStorage;
+                    List<RefPtr<ParamDecl>> * params = nullptr;
                     if (auto func = funcType->declRef.getDecl())
                     {
                         paramsStorage = func->GetParameters().ToArray();
@@ -4554,8 +4554,8 @@ namespace Slang
                         {
                             if ((*params)[i]->HasModifier<OutModifier>())
                             {
-                                if (i < expr->Arguments.Count() && expr->Arguments[i]->Type->AsBasicType() &&
-                                    !expr->Arguments[i]->Type.IsLeftValue)
+                                if (i < expr->Arguments.Count() && expr->Arguments[i]->type->AsBasicType() &&
+                                    !expr->Arguments[i]->type.IsLeftValue)
                                 {
                                     if (!isRewriteMode())
                                     {
@@ -4570,7 +4570,7 @@ namespace Slang
             return rs;
         }
 
-        RefPtr<ExpressionSyntaxNode> visitInvokeExpressionSyntaxNode(InvokeExpressionSyntaxNode *expr)
+        RefPtr<Expr> visitInvokeExpr(InvokeExpr *expr)
         {
             // check the base expression first
             expr->FunctionExpr = CheckExpr(expr->FunctionExpr);
@@ -4585,13 +4585,13 @@ namespace Slang
         }
 
 
-        RefPtr<ExpressionSyntaxNode> visitVarExpressionSyntaxNode(VarExpressionSyntaxNode *expr)
+        RefPtr<Expr> visitVarExpr(VarExpr *expr)
         {
             // If we've already resolved this expression, don't try again.
             if (expr->declRef)
                 return expr;
 
-            expr->Type = QualType(getSession()->getErrorType());
+            expr->type = QualType(getSession()->getErrorType());
 
             auto lookupResult = LookUp(
                 getSession(),
@@ -4612,22 +4612,22 @@ namespace Slang
             return expr;
         }
 
-        RefPtr<ExpressionSyntaxNode> visitTypeCastExpressionSyntaxNode(TypeCastExpressionSyntaxNode * expr)
+        RefPtr<Expr> visitTypeCastExpr(TypeCastExpr * expr)
         {
             expr->Expression = CheckTerm(expr->Expression);
             auto targetType = CheckProperType(expr->TargetType);
             expr->TargetType = targetType;
 
             // The way to perform casting depends on the types involved
-            if (expr->Expression->Type->Equals(getSession()->getErrorType()))
+            if (expr->Expression->type->Equals(getSession()->getErrorType()))
             {
                 // If the expression being casted has an error type, then just silently succeed
-                expr->Type = targetType.Ptr();
+                expr->type = targetType.Ptr();
                 return expr;
             }
             else if (auto targetArithType = targetType->AsArithmeticType())
             {
-                if (auto exprArithType = expr->Expression->Type->AsArithmeticType())
+                if (auto exprArithType = expr->Expression->type->AsArithmeticType())
                 {
                     // Both source and destination types are arithmetic, so we might
                     // have a valid cast
@@ -4639,7 +4639,7 @@ namespace Slang
 
                     // TODO(tfoley): this checking is incomplete here, and could
                     // lead to downstream compilation failures
-                    expr->Type = targetType.Ptr();
+                    expr->type = targetType.Ptr();
                     return expr;
                 }
             }
@@ -4650,9 +4650,9 @@ namespace Slang
             // Default: in no other case succeds, then the cast failed and we emit a diagnostic.
             if (!isRewriteMode())
             {
-                getSink()->diagnose(expr, Diagnostics::invalidTypeCast, expr->Expression->Type, targetType->ToString());
+                getSink()->diagnose(expr, Diagnostics::invalidTypeCast, expr->Expression->type, targetType->ToString());
             }
-            expr->Type = QualType(getSession()->getErrorType());
+            expr->type = QualType(getSession()->getErrorType());
             return expr;
         }
 
@@ -4673,25 +4673,25 @@ namespace Slang
         // deal with this cases here, even if they are no-ops.
         //
 
-        RefPtr<ExpressionSyntaxNode> visitDerefExpr(DerefExpr* expr)
+        RefPtr<Expr> visitDerefExpr(DerefExpr* expr)
         {
             SLANG_DIAGNOSE_UNEXPECTED(getSink(), expr, "should not appear in input syntax");
             return expr;
         }
 
-        RefPtr<ExpressionSyntaxNode> visitSwizzleExpr(SwizzleExpr* expr)
+        RefPtr<Expr> visitSwizzleExpr(SwizzleExpr* expr)
         {
             SLANG_DIAGNOSE_UNEXPECTED(getSink(), expr, "should not appear in input syntax");
             return expr;
         }
 
-        RefPtr<ExpressionSyntaxNode> visitOverloadedExpr(OverloadedExpr* expr)
+        RefPtr<Expr> visitOverloadedExpr(OverloadedExpr* expr)
         {
             SLANG_DIAGNOSE_UNEXPECTED(getSink(), expr, "should not appear in input syntax");
             return expr;
         }
 
-        RefPtr<ExpressionSyntaxNode> visitAggTypeCtorExpr(AggTypeCtorExpr* expr)
+        RefPtr<Expr> visitAggTypeCtorExpr(AggTypeCtorExpr* expr)
         {
             SLANG_DIAGNOSE_UNEXPECTED(getSink(), expr, "should not appear in input syntax");
             return expr;
@@ -4701,19 +4701,19 @@ namespace Slang
         //
         //
 
-        RefPtr<ExpressionSyntaxNode> MaybeDereference(RefPtr<ExpressionSyntaxNode> inExpr)
+        RefPtr<Expr> MaybeDereference(RefPtr<Expr> inExpr)
         {
-            RefPtr<ExpressionSyntaxNode> expr = inExpr;
+            RefPtr<Expr> expr = inExpr;
             for (;;)
             {
-                auto& type = expr->Type;
+                auto& type = expr->type;
                 if (auto pointerLikeType = type->As<PointerLikeType>())
                 {
                     type = QualType(pointerLikeType->elementType);
 
                     auto derefExpr = new DerefExpr();
                     derefExpr->base = expr;
-                    derefExpr->Type = QualType(pointerLikeType->elementType);
+                    derefExpr->type = QualType(pointerLikeType->elementType);
 
                     // TODO(tfoley): deal with l-value-ness here
 
@@ -4726,9 +4726,9 @@ namespace Slang
             }
         }
 
-        RefPtr<ExpressionSyntaxNode> CheckSwizzleExpr(
-            MemberExpressionSyntaxNode* memberRefExpr,
-            RefPtr<ExpressionType>      baseElementType,
+        RefPtr<Expr> CheckSwizzleExpr(
+            MemberExpr* memberRefExpr,
+            RefPtr<Type>      baseElementType,
             IntegerLiteralValue         baseElementCount)
         {
             RefPtr<SwizzleExpr> swizExpr = new SwizzleExpr();
@@ -4806,27 +4806,27 @@ namespace Slang
                 // Note(tfoley): the official HLSL rules seem to be that it produces
                 // a one-component vector, which is then implicitly convertible to
                 // a scalar, but that seems like it just adds complexity.
-                swizExpr->Type = QualType(baseElementType);
+                swizExpr->type = QualType(baseElementType);
             }
             else
             {
                 // TODO(tfoley): would be nice to "re-sugar" type
                 // here if the input type had a sugared name...
-                swizExpr->Type = QualType(createVectorType(
+                swizExpr->type = QualType(createVectorType(
                     baseElementType,
                     new ConstantIntVal(elementCount)));
             }
 
             // A swizzle can be used as an l-value as long as there
             // were no duplicates in the list of components
-            swizExpr->Type.IsLeftValue = !anyDuplicates;
+            swizExpr->type.IsLeftValue = !anyDuplicates;
 
             return swizExpr;
         }
 
-        RefPtr<ExpressionSyntaxNode> CheckSwizzleExpr(
-            MemberExpressionSyntaxNode*	memberRefExpr,
-            RefPtr<ExpressionType>		baseElementType,
+        RefPtr<Expr> CheckSwizzleExpr(
+            MemberExpr*	memberRefExpr,
+            RefPtr<Type>		baseElementType,
             RefPtr<IntVal>				baseElementCount)
         {
             if (auto constantElementCount = baseElementCount.As<ConstantIntVal>())
@@ -4844,13 +4844,13 @@ namespace Slang
         }
 
 
-        RefPtr<ExpressionSyntaxNode> visitMemberExpressionSyntaxNode(MemberExpressionSyntaxNode * expr)
+        RefPtr<Expr> visitMemberExpr(MemberExpr * expr)
         {
             expr->BaseExpression = CheckExpr(expr->BaseExpression);
 
             expr->BaseExpression = MaybeDereference(expr->BaseExpression);
 
-            auto & baseType = expr->BaseExpression->Type;
+            auto & baseType = expr->BaseExpression->type;
 
             // Note: Checking for vector types before declaration-reference types,
             // because vectors are also declaration reference types...
@@ -4930,16 +4930,16 @@ namespace Slang
                 {
                     getSink()->diagnose(expr, Diagnostics::noMemberOfNameInType, expr->name, baseType);
                 }
-                expr->Type = QualType(getSession()->getErrorType());
+                expr->type = QualType(getSession()->getErrorType());
                 return expr;
             }
             // All remaining cases assume we have a `BasicType`
             else if (!baseType->AsBasicType())
-                expr->Type = QualType(getSession()->getErrorType());
+                expr->type = QualType(getSession()->getErrorType());
             else
-                expr->Type = QualType(getSession()->getErrorType());
+                expr->type = QualType(getSession()->getErrorType());
             if (!baseType->Equals(getSession()->getErrorType()) &&
-                expr->Type->Equals(getSession()->getErrorType()))
+                expr->type->Equals(getSession()->getErrorType()))
             {
                 if (!isRewriteMode())
                 {
@@ -4953,7 +4953,7 @@ namespace Slang
 
         //
 
-        RefPtr<ExpressionSyntaxNode> visitInitializerListExpr(InitializerListExpr* expr)
+        RefPtr<Expr> 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
@@ -4964,12 +4964,12 @@ namespace Slang
                 arg = CheckTerm(arg);
             }
 
-            expr->Type = getSession()->getInitializerListType();
+            expr->type = getSession()->getInitializerListType();
 
             return expr;
         }
 
-        void importModuleIntoScope(Scope* scope, ProgramSyntaxNode* moduleDecl)
+        void importModuleIntoScope(Scope* scope, ModuleDecl* moduleDecl)
         {
             // If we've imported this one already, then
             // skip the step where we modify the current scope.
@@ -5053,7 +5053,7 @@ namespace Slang
         SemanticsVisitor*       sema,
         DiagnosticSink*         sink,
         DeclRef<Decl>           declRef,
-        RefPtr<ExpressionType>* outTypeResult)
+        RefPtr<Type>* outTypeResult)
     {
         if( sema )
         {
@@ -5110,14 +5110,14 @@ namespace Slang
         Session*        session,
         DeclRef<Decl>   declRef)
     {
-        RefPtr<ExpressionType> typeResult;
+        RefPtr<Type> typeResult;
         return getTypeForDeclRef(session, nullptr, nullptr, declRef, &typeResult);
     }
 
     DeclRef<ExtensionDecl> ApplyExtensionToType(
         SemanticsVisitor*       semantics,
         ExtensionDecl*          extDecl,
-        RefPtr<ExpressionType>  type)
+        RefPtr<Type>  type)
     {
         if(!semantics)
             return DeclRef<ExtensionDecl>();
diff --git a/source/slang/compiler.h b/source/slang/compiler.h
index 8fcbd444d..fd40a62f6 100644
--- a/source/slang/compiler.h
+++ b/source/slang/compiler.h
@@ -162,7 +162,7 @@ namespace Slang
         SlangCompileFlags compileFlags = 0;
 
         // The parsed syntax for the translation unit
-        RefPtr<ProgramSyntaxNode>   SyntaxNode;
+        RefPtr<ModuleDecl>   SyntaxNode;
 
         // The resulting output for the translation unit
         //
@@ -241,13 +241,13 @@ namespace Slang
         // Modules that have been dynamically loaded via `import`
         //
         // This is a list of unique modules loaded, in the order they were encountered.
-        List<RefPtr<ProgramSyntaxNode> > loadedModulesList;
+        List<RefPtr<ModuleDecl> > loadedModulesList;
 
         // Map from the logical name of a module to its definition
-        Dictionary<String, RefPtr<ProgramSyntaxNode>> mapPathToLoadedModule;
+        Dictionary<String, RefPtr<ModuleDecl>> mapPathToLoadedModule;
 
         // Map from the path of a module file to its definition
-        Dictionary<String, RefPtr<ProgramSyntaxNode>> mapNameToLoadedModules;
+        Dictionary<String, RefPtr<ModuleDecl>> mapNameToLoadedModules;
 
 
         CompileRequest(Session* session)
@@ -281,7 +281,7 @@ namespace Slang
             String const&           name,
             Profile                 profile);
 
-        RefPtr<ProgramSyntaxNode> loadModule(
+        RefPtr<ModuleDecl> loadModule(
             String const&       name,
             String const&       path,
             String const&       source,
@@ -291,7 +291,7 @@ namespace Slang
             String const&       path,
             TokenList const&    tokens);
 
-        RefPtr<ProgramSyntaxNode> findOrImportModule(
+        RefPtr<ModuleDecl> findOrImportModule(
             String const&       name,
             CodePosition const& loc);
     };
@@ -322,7 +322,7 @@ namespace Slang
         RefPtr<Scope>   slangLanguageScope;
         RefPtr<Scope>   glslLanguageScope;
 
-        List<RefPtr<ProgramSyntaxNode>> loadedModuleCode;
+        List<RefPtr<ModuleDecl>> loadedModuleCode;
 
 
         //
@@ -340,27 +340,27 @@ namespace Slang
         String getGLSLLibraryCode();
 
         // Basic types that we don't want to re-create all the time
-        RefPtr<ExpressionType> errorType;
-        RefPtr<ExpressionType> initializerListType;
-        RefPtr<ExpressionType> overloadedType;
+        RefPtr<Type> errorType;
+        RefPtr<Type> initializerListType;
+        RefPtr<Type> overloadedType;
 
-        Dictionary<int, RefPtr<ExpressionType>> builtinTypes;
+        Dictionary<int, RefPtr<Type>> builtinTypes;
         Dictionary<String, Decl*> magicDecls;
-        List<RefPtr<ExpressionType>> canonicalTypes;
+        List<RefPtr<Type>> canonicalTypes;
 
         void initializeTypes();
 
-        ExpressionType* getBoolType();
-        ExpressionType* getFloatType();
-        ExpressionType* getDoubleType();
-        ExpressionType* getIntType();
-        ExpressionType* getUIntType();
-        ExpressionType* getVoidType();
-        ExpressionType* getBuiltinType(BaseType flavor);
-
-        ExpressionType* getInitializerListType();
-        ExpressionType* getOverloadedType();
-        ExpressionType* getErrorType();
+        Type* getBoolType();
+        Type* getFloatType();
+        Type* getDoubleType();
+        Type* getIntType();
+        Type* getUIntType();
+        Type* getVoidType();
+        Type* getBuiltinType(BaseType flavor);
+
+        Type* getInitializerListType();
+        Type* getOverloadedType();
+        Type* getErrorType();
 
         //
 
diff --git a/source/slang/decl-defs.h b/source/slang/decl-defs.h
index f2405b0f0..4f219e63c 100644
--- a/source/slang/decl-defs.h
+++ b/source/slang/decl-defs.h
@@ -36,15 +36,15 @@ END_SYNTAX_CLASS()
 // Base class for all variable-like declarations
 ABSTRACT_SYNTAX_CLASS(VarDeclBase, Decl)
 
-    // Type of the variable
-    SYNTAX_FIELD(TypeExp, Type)
+    // type of the variable
+    SYNTAX_FIELD(TypeExp, type)
 
     RAW(
-    ExpressionType* getType() { return Type.type.Ptr(); }
+    Type* getType() { return type.type.Ptr(); }
     )
 
     // Initializer expression (optional)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, Expr)
+    SYNTAX_FIELD(RefPtr<Expr>, initExpr)
 END_SYNTAX_CLASS()
 
 
@@ -103,9 +103,9 @@ RAW(
     )
 END_SYNTAX_CLASS()
 
-SIMPLE_SYNTAX_CLASS(StructSyntaxNode, AggTypeDecl)
+SIMPLE_SYNTAX_CLASS(StructDecl, AggTypeDecl)
 
-SIMPLE_SYNTAX_CLASS(ClassSyntaxNode, AggTypeDecl)
+SIMPLE_SYNTAX_CLASS(ClassDecl, AggTypeDecl)
 
 // An interface which other types can conform to
 SIMPLE_SYNTAX_CLASS(InterfaceDecl, AggTypeDecl)
@@ -130,20 +130,20 @@ END_SYNTAX_CLASS()
 
 // A `typedef` declaration
 SYNTAX_CLASS(TypeDefDecl, SimpleTypeDecl)
-    SYNTAX_FIELD(TypeExp, Type)
+    SYNTAX_FIELD(TypeExp, type)
 END_SYNTAX_CLASS()
 
 // A scope for local declarations (e.g., as part of a statement)
 SIMPLE_SYNTAX_CLASS(ScopeDecl, ContainerDecl)
 
-SIMPLE_SYNTAX_CLASS(ParameterSyntaxNode, VarDeclBase)
+SIMPLE_SYNTAX_CLASS(ParamDecl, VarDeclBase)
 
 // Base class for things that have parameter lists and can thus be applied to arguments ("called")
 ABSTRACT_SYNTAX_CLASS(CallableDecl, ContainerDecl)
     RAW(
-    FilteredMemberList<ParameterSyntaxNode> GetParameters()
+    FilteredMemberList<ParamDecl> GetParameters()
     {
-        return getMembersOfType<ParameterSyntaxNode>();
+        return getMembersOfType<ParamDecl>();
     })
 
     SYNTAX_FIELD(TypeExp, ReturnType)
@@ -151,7 +151,7 @@ END_SYNTAX_CLASS()
 
 // Base class for callable things that may also have a body that is evaluated to produce their result
 ABSTRACT_SYNTAX_CLASS(FunctionDeclBase, CallableDecl)
-    SYNTAX_FIELD(RefPtr<StatementSyntaxNode>, Body)
+    SYNTAX_FIELD(RefPtr<Stmt>, Body)
 END_SYNTAX_CLASS()
 
 // A constructor/initializer to create instances of a type
@@ -166,13 +166,13 @@ SIMPLE_SYNTAX_CLASS(AccessorDecl, FunctionDeclBase)
 SIMPLE_SYNTAX_CLASS(GetterDecl, AccessorDecl)
 SIMPLE_SYNTAX_CLASS(SetterDecl, AccessorDecl)
 
-SIMPLE_SYNTAX_CLASS(FunctionSyntaxNode, FunctionDeclBase)
+SIMPLE_SYNTAX_CLASS(FuncDecl, FunctionDeclBase)
 
 SIMPLE_SYNTAX_CLASS(Variable, VarDeclBase);
 
 // A "module" of code (essentiately, a single translation unit)
 // that provides a scope for some number of declarations.
-SIMPLE_SYNTAX_CLASS(ProgramSyntaxNode, ContainerDecl)
+SIMPLE_SYNTAX_CLASS(ModuleDecl, ContainerDecl)
 
 SYNTAX_CLASS(ImportDecl, Decl)
     // The name of the module we are trying to import
@@ -182,7 +182,7 @@ SYNTAX_CLASS(ImportDecl, Decl)
     FIELD(RefPtr<Scope>, scope)
 
     // The module that actually got imported
-    DECL_FIELD(RefPtr<ProgramSyntaxNode>, importedModuleDecl)
+    DECL_FIELD(RefPtr<ModuleDecl>, importedModuleDecl)
 END_SYNTAX_CLASS()
 
 // A generic declaration, parameterized on types/values
diff --git a/source/slang/diagnostics.cpp b/source/slang/diagnostics.cpp
index d23f2bd16..e0b959a81 100644
--- a/source/slang/diagnostics.cpp
+++ b/source/slang/diagnostics.cpp
@@ -42,7 +42,7 @@ void printDiagnosticArg(StringBuilder& sb, Decl* decl)
     sb << decl->Name.Content;
 }
 
-void printDiagnosticArg(StringBuilder& sb, ExpressionType* type)
+void printDiagnosticArg(StringBuilder& sb, Type* type)
 {
     sb << type->ToString();
 }
diff --git a/source/slang/diagnostics.h b/source/slang/diagnostics.h
index f88bf460e..6ea677b38 100644
--- a/source/slang/diagnostics.h
+++ b/source/slang/diagnostics.h
@@ -68,8 +68,8 @@ namespace Slang
     };
 
     class Decl;
+    class type;
     class Type;
-    class ExpressionType;
     class ILType;
     class StageAttribute;
     struct TypeExp;
@@ -80,8 +80,8 @@ namespace Slang
     void printDiagnosticArg(StringBuilder& sb, UInt val);
     void printDiagnosticArg(StringBuilder& sb, Slang::String const& str);
     void printDiagnosticArg(StringBuilder& sb, Decl* decl);
+    void printDiagnosticArg(StringBuilder& sb, type* type);
     void printDiagnosticArg(StringBuilder& sb, Type* type);
-    void printDiagnosticArg(StringBuilder& sb, ExpressionType* type);
     void printDiagnosticArg(StringBuilder& sb, TypeExp const& type);
     void printDiagnosticArg(StringBuilder& sb, QualType const& type);
     void printDiagnosticArg(StringBuilder& sb, TokenType tokenType);
diff --git a/source/slang/emit.cpp b/source/slang/emit.cpp
index d2f932ebf..72632260f 100644
--- a/source/slang/emit.cpp
+++ b/source/slang/emit.cpp
@@ -71,7 +71,7 @@ struct SharedEmitContext
 
     // We only want to emit each `import`ed module one time, so
     // we maintain a set of already-emitted modules.
-    HashSet<ProgramSyntaxNode*> modulesAlreadyEmitted;
+    HashSet<ModuleDecl*> modulesAlreadyEmitted;
 
     // We track the original global-scope layout so that we can
     // find layout information for `import`ed parameters.
@@ -82,7 +82,7 @@ struct SharedEmitContext
 
     ProgramLayout*      programLayout;
 
-    ProgramSyntaxNode*  program;
+    ModuleDecl*  program;
 
     bool                needHackSamplerForTexelFetch = false;
 
@@ -124,7 +124,7 @@ void requireGLSLVersion(
 static String getStringOrIdentifierTokenValue(
     Token const& token)
 {
-    switch(token.Type)
+    switch(token.type)
     {
     default:
         SLANG_UNEXPECTED("needed an identifier or string literal");
@@ -793,7 +793,7 @@ struct EmitVisitor
     }
 
     void emitGLSLTypePrefix(
-        RefPtr<ExpressionType>  type)
+        RefPtr<Type>  type)
     {
         if(auto basicElementType = type->As<BasicExpressionType>())
         {
@@ -980,7 +980,7 @@ struct EmitVisitor
         }
     }
 
-    void emitTypeImpl(RefPtr<ExpressionType> type, EDeclarator* declarator)
+    void emitTypeImpl(RefPtr<Type> type, EDeclarator* declarator)
     {
         TypeEmitArg arg;
         arg.declarator = declarator;
@@ -1186,7 +1186,7 @@ struct EmitVisitor
     }
 
     void EmitType(
-        RefPtr<ExpressionType>  type,
+        RefPtr<Type>  type,
         CodePosition const&     typeLoc,
         String const&           name,
         CodePosition const&     nameLoc)
@@ -1201,19 +1201,19 @@ struct EmitVisitor
     }
 
 
-    void EmitType(RefPtr<ExpressionType> type, Token const& nameToken)
+    void EmitType(RefPtr<Type> type, Token const& nameToken)
     {
         EmitType(type, CodePosition(), nameToken.Content, nameToken.Position);
     }
 
-    void EmitType(RefPtr<ExpressionType> type)
+    void EmitType(RefPtr<Type> type)
     {
         emitTypeImpl(type, nullptr);
     }
 
-    void emitTypeBasedOnExpr(ExpressionSyntaxNode* expr, EDeclarator* declarator)
+    void emitTypeBasedOnExpr(Expr* expr, EDeclarator* declarator)
     {
-        if (auto subscriptExpr = dynamic_cast<IndexExpressionSyntaxNode*>(expr))
+        if (auto subscriptExpr = dynamic_cast<IndexExpr*>(expr))
         {
             // Looks like an array
             emitTypeBasedOnExpr(subscriptExpr->BaseExpression, declarator);
@@ -1278,13 +1278,13 @@ struct EmitVisitor
 
     // Determine if an expression should not be emitted when it is the base of
     // a member reference expression.
-    bool IsBaseExpressionImplicit(RefPtr<ExpressionSyntaxNode> expr)
+    bool IsBaseExpressionImplicit(RefPtr<Expr> expr)
     {
         // HACK(tfoley): For now, anything with a constant-buffer type should be
         // left implicit.
 
         // Look through any dereferencing that took place
-        RefPtr<ExpressionSyntaxNode> e = expr;
+        RefPtr<Expr> e = expr;
         while (auto derefExpr = e.As<DerefExpr>())
         {
             e = derefExpr->base;
@@ -1298,7 +1298,7 @@ struct EmitVisitor
         }
 
         // Is the expression referencing a constant buffer?
-        if (auto cbufferType = e->Type->As<ConstantBufferType>())
+        if (auto cbufferType = e->type->As<ConstantBufferType>())
         {
             return true;
         }
@@ -1307,13 +1307,13 @@ struct EmitVisitor
     }
 
 #if 0
-    void EmitPostfixExpr(RefPtr<ExpressionSyntaxNode> expr)
+    void EmitPostfixExpr(RefPtr<Expr> expr)
     {
         EmitExprWithPrecedence(expr, kEOp_Postfix);
     }
 #endif
 
-    void EmitExpr(RefPtr<ExpressionSyntaxNode> expr)
+    void EmitExpr(RefPtr<Expr> expr)
     {
         EmitExprWithPrecedence(expr, kEOp_General);
     }
@@ -1336,12 +1336,12 @@ struct EmitVisitor
     // we may need to ignore certain constructs that the type-checker
     // might have introduced, but which interfere with our ability
     // to use it effectively in the target language
-    RefPtr<ExpressionSyntaxNode> prepareLValueExpr(
-        RefPtr<ExpressionSyntaxNode>    expr)
+    RefPtr<Expr> prepareLValueExpr(
+        RefPtr<Expr>    expr)
     {
         for(;;)
         {
-            if(auto typeCastExpr = expr.As<TypeCastExpressionSyntaxNode>())
+            if(auto typeCastExpr = expr.As<TypeCastExpr>())
             {
                 expr = typeCastExpr->Expression;
             }
@@ -1358,7 +1358,7 @@ struct EmitVisitor
         EOpInfo outerPrec,
         EOpInfo prec,
         char const* op,
-        RefPtr<InvokeExpressionSyntaxNode> binExpr,
+        RefPtr<InvokeExpr> binExpr,
         bool isAssign)
     {
         bool needsClose = MaybeEmitParens(outerPrec, prec);
@@ -1380,12 +1380,12 @@ struct EmitVisitor
         }
     }
 
-    void EmitBinExpr(EOpInfo outerPrec, EOpInfo prec, char const* op, RefPtr<InvokeExpressionSyntaxNode> binExpr)
+    void EmitBinExpr(EOpInfo outerPrec, EOpInfo prec, char const* op, RefPtr<InvokeExpr> binExpr)
     {
         emitInfixExprImpl(outerPrec, prec, op, binExpr, false);
     }
 
-    void EmitBinAssignExpr(EOpInfo outerPrec, EOpInfo prec, char const* op, RefPtr<InvokeExpressionSyntaxNode> binExpr)
+    void EmitBinAssignExpr(EOpInfo outerPrec, EOpInfo prec, char const* op, RefPtr<InvokeExpr> binExpr)
     {
         emitInfixExprImpl(outerPrec, prec, op, binExpr, true);
     }
@@ -1395,7 +1395,7 @@ struct EmitVisitor
         EOpInfo prec,
         char const* preOp,
         char const* postOp,
-        RefPtr<InvokeExpressionSyntaxNode> expr,
+        RefPtr<InvokeExpr> expr,
         bool isAssign)
     {
         bool needsClose = MaybeEmitParens(outerPrec, prec);
@@ -1429,7 +1429,7 @@ struct EmitVisitor
         EOpInfo prec,
         char const* preOp,
         char const* postOp,
-        RefPtr<InvokeExpressionSyntaxNode> expr)
+        RefPtr<InvokeExpr> expr)
     {
         emitUnaryExprImpl(outerPrec, prec, preOp, postOp, expr, false);
     }
@@ -1439,7 +1439,7 @@ struct EmitVisitor
         EOpInfo prec,
         char const* preOp,
         char const* postOp,
-        RefPtr<InvokeExpressionSyntaxNode> expr)
+        RefPtr<InvokeExpr> expr)
     {
         emitUnaryExprImpl(outerPrec, prec, preOp, postOp, expr, true);
     }
@@ -1453,7 +1453,7 @@ struct EmitVisitor
 
         // If no target name was specified, then the modifier implicitly
         // applies to all targets.
-        if(targetToken.Type == TokenType::Unknown)
+        if(targetToken.type == TokenType::Unknown)
             return true;
 
         // Otherwise, we need to check if the target name matches what
@@ -1486,7 +1486,7 @@ struct EmitVisitor
             // For now "better"-ness is defined as: a modifier
             // with a specified target is better than one without
             // (it is more specific)
-            if(!bestModifier || bestModifier->targetToken.Type == TokenType::Unknown)
+            if(!bestModifier || bestModifier->targetToken.type == TokenType::Unknown)
             {
                 bestModifier = m;
             }
@@ -1498,7 +1498,7 @@ struct EmitVisitor
     // Emit a call expression that doesn't involve any special cases,
     // just an expression of the form `f(a0, a1, ...)`
     void emitSimpleCallExpr(
-        RefPtr<InvokeExpressionSyntaxNode>  callExpr,
+        RefPtr<InvokeExpr>  callExpr,
         EOpInfo                             outerPrec)
     {
         auto prec = kEOp_Postfix;
@@ -1511,7 +1511,7 @@ struct EmitVisitor
             if (auto ctorDeclRef = declRef.As<ConstructorDecl>())
             {
                 // We really want to emit a reference to the type begin constructed
-                EmitType(callExpr->Type);
+                EmitType(callExpr->type);
             }
             else
             {
@@ -1583,7 +1583,7 @@ struct EmitVisitor
         return result;
     }
 
-    void EmitExprWithPrecedence(RefPtr<ExpressionSyntaxNode> expr, EOpInfo outerPrec)
+    void EmitExprWithPrecedence(RefPtr<Expr> expr, EOpInfo outerPrec)
     {
         ExprEmitArg arg;
         arg.outerPrec = outerPrec;
@@ -1591,7 +1591,7 @@ struct EmitVisitor
         ExprVisitorWithArg::dispatch(expr, arg);
     }
 
-    void EmitExprWithPrecedence(RefPtr<ExpressionSyntaxNode> expr, EPrecedence leftPrec, EPrecedence rightPrec)
+    void EmitExprWithPrecedence(RefPtr<Expr> expr, EPrecedence leftPrec, EPrecedence rightPrec)
     {
         EOpInfo outerPrec;
         outerPrec.leftPrecedence = leftPrec;
@@ -1626,7 +1626,7 @@ struct EmitVisitor
         emitTypeExp(expr->base);
     }
 
-    void visitSelectExpressionSyntaxNode(SelectExpressionSyntaxNode* selectExpr, ExprEmitArg const& arg)
+    void visitSelectExpr(SelectExpr* selectExpr, ExprEmitArg const& arg)
     {
         auto prec = kEOp_Conditional;
         auto outerPrec = arg.outerPrec;
@@ -1662,7 +1662,7 @@ struct EmitVisitor
     }
 
     void emitUncheckedCallExpr(
-        RefPtr<InvokeExpressionSyntaxNode>  callExpr,
+        RefPtr<InvokeExpr>  callExpr,
         String const&                       funcName,
         ExprEmitArg const&                  arg)
     {
@@ -1765,8 +1765,8 @@ struct EmitVisitor
         }
     }
 
-    void visitInvokeExpressionSyntaxNode(
-        RefPtr<InvokeExpressionSyntaxNode>  callExpr,
+    void visitInvokeExpr(
+        RefPtr<InvokeExpr>  callExpr,
         ExprEmitArg const& arg)
     {
         auto outerPrec = arg.outerPrec;
@@ -1896,7 +1896,7 @@ struct EmitVisitor
                 }
 
 
-                if(targetIntrinsicModifier->definitionToken.Type != TokenType::Unknown)
+                if(targetIntrinsicModifier->definitionToken.type != TokenType::Unknown)
                 {
                     auto name = getStringOrIdentifierTokenValue(targetIntrinsicModifier->definitionToken);
 
@@ -1958,7 +1958,7 @@ struct EmitVisitor
                             case 'o':
                                 // For a call using object-oriented syntax, this
                                 // expands to the "base" object used for the call
-                                if (auto memberExpr = callExpr->FunctionExpr.As<MemberExpressionSyntaxNode>())
+                                if (auto memberExpr = callExpr->FunctionExpr.As<MemberExpr>())
                                 {
                                     Emit("(");
                                     EmitExpr(memberExpr->BaseExpression);
@@ -1975,14 +1975,14 @@ struct EmitVisitor
                                 // then this form will pair up the t and s arguments as needed for a GLSL
                                 // texturing operation.
                                 SLANG_RELEASE_ASSERT(argCount > 0);
-                                if (auto memberExpr = callExpr->FunctionExpr.As<MemberExpressionSyntaxNode>())
+                                if (auto memberExpr = callExpr->FunctionExpr.As<MemberExpr>())
                                 {
                                     auto base = memberExpr->BaseExpression;
-                                    if (auto baseTextureType = base->Type->As<TextureType>())
+                                    if (auto baseTextureType = base->type->As<TextureType>())
                                     {
                                         emitGLSLTextureOrTextureSamplerType(baseTextureType, "sampler");
 
-                                        if (auto samplerType = callExpr->Arguments[0]->Type.type->As<SamplerStateType>())
+                                        if (auto samplerType = callExpr->Arguments[0]->type.type->As<SamplerStateType>())
                                         {
                                             if (samplerType->flavor == SamplerStateType::Flavor::SamplerComparisonState)
                                             {
@@ -2027,7 +2027,7 @@ struct EmitVisitor
                                     {
                                         if (auto varDecl = dd.As<VarDeclBase>())
                                         {
-                                            if (auto samplerType = varDecl->Type.type->As<SamplerStateType>())
+                                            if (auto samplerType = varDecl->type.type->As<SamplerStateType>())
                                             {
                                                 samplerVar = varDecl;
                                                 break;
@@ -2035,10 +2035,10 @@ struct EmitVisitor
                                         }
                                     }
 
-                                    if (auto memberExpr = callExpr->FunctionExpr.As<MemberExpressionSyntaxNode>())
+                                    if (auto memberExpr = callExpr->FunctionExpr.As<MemberExpr>())
                                     {
                                         auto base = memberExpr->BaseExpression;
-                                        if (auto baseTextureType = base->Type->As<TextureType>())
+                                        if (auto baseTextureType = base->type->As<TextureType>())
                                         {
                                             emitGLSLTextureOrTextureSamplerType(baseTextureType, "sampler");
                                             Emit("(");
@@ -2074,10 +2074,10 @@ struct EmitVisitor
                                 // properly swizzle the output of the equivalent GLSL call into the right
                                 // shape.
                                 SLANG_RELEASE_ASSERT(argCount > 0);
-                                if (auto memberExpr = callExpr->FunctionExpr.As<MemberExpressionSyntaxNode>())
+                                if (auto memberExpr = callExpr->FunctionExpr.As<MemberExpr>())
                                 {
                                     auto base = memberExpr->BaseExpression;
-                                    if (auto baseTextureType = base->Type->As<TextureType>())
+                                    if (auto baseTextureType = base->type->As<TextureType>())
                                     {
                                         auto elementType = baseTextureType->elementType;
                                         if (auto basicType = elementType->As<BasicExpressionType>())
@@ -2134,7 +2134,7 @@ struct EmitVisitor
                 {
                     // We expect any subscript operation to be invoked as a member,
                     // so the function expression had better be in the correct form.
-                    if(auto memberExpr = funcExpr.As<MemberExpressionSyntaxNode>())
+                    if(auto memberExpr = funcExpr.As<MemberExpr>())
                     {
 
                         Emit("(");
@@ -2182,7 +2182,7 @@ struct EmitVisitor
         if(needClose) Emit(")");
     }
 
-    void visitMemberExpressionSyntaxNode(MemberExpressionSyntaxNode* memberExpr, ExprEmitArg const& arg)
+    void visitMemberExpr(MemberExpr* memberExpr, ExprEmitArg const& arg)
     {
         auto prec = kEOp_Postfix;
         auto outerPrec = arg.outerPrec;
@@ -2238,7 +2238,7 @@ struct EmitVisitor
         if(needClose) Emit(")");
     }
 
-    void visitIndexExpressionSyntaxNode(IndexExpressionSyntaxNode* subscriptExpr, ExprEmitArg const& arg)
+    void visitIndexExpr(IndexExpr* subscriptExpr, ExprEmitArg const& arg)
     {
         auto prec = kEOp_Postfix;
         auto outerPrec = arg.outerPrec;
@@ -2260,7 +2260,7 @@ struct EmitVisitor
         emitName(expr->lookupResult2.getName());
     }
 
-    void visitVarExpressionSyntaxNode(VarExpressionSyntaxNode* varExpr, ExprEmitArg const& arg)
+    void visitVarExpr(VarExpr* varExpr, ExprEmitArg const& arg)
     {
         auto prec = kEOp_Atomic;
         auto outerPrec = arg.outerPrec;
@@ -2297,16 +2297,16 @@ struct EmitVisitor
         ExprVisitorWithArg::dispatch(derefExpr->base, arg);
     }
 
-    void visitConstantExpressionSyntaxNode(ConstantExpressionSyntaxNode* litExpr, ExprEmitArg const& arg)
+    void visitConstantExpr(ConstantExpr* litExpr, ExprEmitArg const& arg)
     {
         auto outerPrec = arg.outerPrec;
         bool needClose = MaybeEmitParens(outerPrec, kEOp_Atomic);
 
         char const* suffix = "";
-        auto type = litExpr->Type.type;
+        auto type = litExpr->type.type;
         switch (litExpr->ConstType)
         {
-        case ConstantExpressionSyntaxNode::ConstantType::Int:
+        case ConstantExpr::ConstantType::Int:
             if(!type)
             {
                 // Special case for "rewrite" mode
@@ -2328,7 +2328,7 @@ struct EmitVisitor
             break;
 
 
-        case ConstantExpressionSyntaxNode::ConstantType::Float:
+        case ConstantExpr::ConstantType::Float:
             if(!type)
             {
                 // Special case for "rewrite" mode
@@ -2349,10 +2349,10 @@ struct EmitVisitor
             Emit(suffix);
             break;
 
-        case ConstantExpressionSyntaxNode::ConstantType::Bool:
+        case ConstantExpr::ConstantType::Bool:
             Emit(litExpr->integerValue ? "true" : "false");
             break;
-        case ConstantExpressionSyntaxNode::ConstantType::String:
+        case ConstantExpr::ConstantType::String:
             emitStringLiteral(litExpr->stringValue);
             break;
         default:
@@ -2369,14 +2369,14 @@ struct EmitVisitor
         ExprVisitorWithArg::dispatch(castExpr->Expression, arg);
     }
 
-    void visitTypeCastExpressionSyntaxNode(TypeCastExpressionSyntaxNode* castExpr, ExprEmitArg const& arg)
+    void visitTypeCastExpr(TypeCastExpr* castExpr, ExprEmitArg const& arg)
     {
         bool needClose = false;
         switch(context->shared->target)
         {
         case CodeGenTarget::GLSL:
             // GLSL requires constructor syntax for all conversions
-            EmitType(castExpr->Type);
+            EmitType(castExpr->type);
             Emit("(");
             EmitExpr(castExpr->Expression);
             Emit(")");
@@ -2391,7 +2391,7 @@ struct EmitVisitor
                 needClose = MaybeEmitParens(outerPrec, prec);
 
                 Emit("(");
-                EmitType(castExpr->Type);
+                EmitType(castExpr->type);
                 Emit(")(");
                 EmitExpr(castExpr->Expression);
                 Emit(")");
@@ -2418,7 +2418,7 @@ struct EmitVisitor
 
     // Emit a statement as a `{}`-enclosed block statement, but avoid adding redundant
     // curly braces if the statement is itself a block statement.
-    void EmitBlockStmt(RefPtr<StatementSyntaxNode> stmt)
+    void EmitBlockStmt(RefPtr<Stmt> stmt)
     {
         // TODO(tfoley): support indenting
         Emit("{\n");
@@ -2433,7 +2433,7 @@ struct EmitVisitor
         Emit("}\n");
     }
 
-    void EmitLoopAttributes(RefPtr<StatementSyntaxNode> decl)
+    void EmitLoopAttributes(RefPtr<Stmt> decl)
     {
         // Don't emit these attributes for GLSL, because it doesn't understand them
         if (context->shared->target == CodeGenTarget::GLSL)
@@ -2467,7 +2467,7 @@ struct EmitVisitor
         Emit("}\n");
     }
 
-    void EmitStmt(RefPtr<StatementSyntaxNode> stmt)
+    void EmitStmt(RefPtr<Stmt> stmt)
     {
         // TODO(tfoley): this shouldn't occur, but sometimes
         // lowering will get confused by an empty function body...
@@ -2495,13 +2495,13 @@ struct EmitVisitor
             EmitUnparsedStmt(unparsedStmt);
             return;
         }
-        else if (auto exprStmt = stmt.As<ExpressionStatementSyntaxNode>())
+        else if (auto exprStmt = stmt.As<ExpressionStmt>())
         {
             EmitExpr(exprStmt->Expression);
             Emit(";\n");
             return;
         }
-        else if (auto returnStmt = stmt.As<ReturnStatementSyntaxNode>())
+        else if (auto returnStmt = stmt.As<ReturnStmt>())
         {
             Emit("return");
             if (auto expr = returnStmt->Expression)
@@ -2512,12 +2512,12 @@ struct EmitVisitor
             Emit(";\n");
             return;
         }
-        else if (auto declStmt = stmt.As<VarDeclrStatementSyntaxNode>())
+        else if (auto declStmt = stmt.As<DeclStmt>())
         {
             EmitDecl(declStmt->decl);
             return;
         }
-        else if (auto ifStmt = stmt.As<IfStatementSyntaxNode>())
+        else if (auto ifStmt = stmt.As<IfStmt>())
         {
             Emit("if(");
             EmitExpr(ifStmt->Predicate);
@@ -2530,7 +2530,7 @@ struct EmitVisitor
             }
             return;
         }
-        else if (auto forStmt = stmt.As<ForStatementSyntaxNode>())
+        else if (auto forStmt = stmt.As<ForStmt>())
         {
             // We are going to always take a `for` loop like:
             //
@@ -2587,7 +2587,7 @@ struct EmitVisitor
 
             return;
         }
-        else if (auto whileStmt = stmt.As<WhileStatementSyntaxNode>())
+        else if (auto whileStmt = stmt.As<WhileStmt>())
         {
             EmitLoopAttributes(whileStmt);
 
@@ -2597,7 +2597,7 @@ struct EmitVisitor
             EmitBlockStmt(whileStmt->Statement);
             return;
         }
-        else if (auto doWhileStmt = stmt.As<DoWhileStatementSyntaxNode>())
+        else if (auto doWhileStmt = stmt.As<DoWhileStmt>())
         {
             EmitLoopAttributes(doWhileStmt);
 
@@ -2608,12 +2608,12 @@ struct EmitVisitor
             Emit(")\n");
             return;
         }
-        else if (auto discardStmt = stmt.As<DiscardStatementSyntaxNode>())
+        else if (auto discardStmt = stmt.As<DiscardStmt>())
         {
             Emit("discard;\n");
             return;
         }
-        else if (auto emptyStmt = stmt.As<EmptyStatementSyntaxNode>())
+        else if (auto emptyStmt = stmt.As<EmptyStmt>())
         {
             return;
         }
@@ -2637,12 +2637,12 @@ struct EmitVisitor
             Emit("default:{}\n");
             return;
         }
-        else if (auto breakStmt = stmt.As<BreakStatementSyntaxNode>())
+        else if (auto breakStmt = stmt.As<BreakStmt>())
         {
             Emit("break;\n");
             return;
         }
-        else if (auto continueStmt = stmt.As<ContinueStatementSyntaxNode>())
+        else if (auto continueStmt = stmt.As<ContinueStmt>())
         {
             Emit("continue;\n");
             return;
@@ -2659,7 +2659,7 @@ struct EmitVisitor
 
     void EmitVal(RefPtr<Val> val)
     {
-        if (auto type = val.As<ExpressionType>())
+        if (auto type = val.As<Type>())
         {
             EmitType(type);
         }
@@ -2745,7 +2745,7 @@ struct EmitVisitor
     IGNORED(GenericTypeParamDecl)
 
     // Not epected to appear (probably dead code)
-    IGNORED(ClassSyntaxNode)
+    IGNORED(ClassDecl)
 
     // Not semantically meaningful for emit, or expected
     // to be lowered out of existence before we get here
@@ -2759,7 +2759,7 @@ struct EmitVisitor
     IGNORED(AggTypeDeclBase)
 
     // Should not appear nested inside other decls
-    IGNORED(ProgramSyntaxNode)
+    IGNORED(ModuleDecl)
 
 #undef IGNORED
 
@@ -2778,7 +2778,7 @@ struct EmitVisitor
         SLANG_RELEASE_ASSERT(context->shared->target != CodeGenTarget::GLSL);
 
         Emit("typedef ");
-        EmitType(decl->Type, decl->Name.Content);
+        EmitType(decl->type, decl->Name.Content);
         Emit(";\n");
     }
 
@@ -2863,7 +2863,7 @@ struct EmitVisitor
             }
 
             emit(mod->nameToken.Content);
-            if(mod->valToken.Type != TokenType::Unknown)
+            if(mod->valToken.type != TokenType::Unknown)
             {
                 Emit(" = ");
                 emit(mod->valToken.Content);
@@ -3000,7 +3000,7 @@ struct EmitVisitor
     #if 0
             Emit(": register(");
             Emit(registerSemantic->registerName.Content);
-            if(registerSemantic->componentMask.Type != TokenType::Unknown)
+            if(registerSemantic->componentMask.type != TokenType::Unknown)
             {
                 Emit(".");
                 Emit(registerSemantic->componentMask.Content);
@@ -3017,7 +3017,7 @@ struct EmitVisitor
 
             Emit(": packoffset(");
             Emit(packOffsetSemantic->registerName.Content);
-            if(packOffsetSemantic->componentMask.Type != TokenType::Unknown)
+            if(packOffsetSemantic->componentMask.type != TokenType::Unknown)
             {
                 Emit(".");
                 Emit(packOffsetSemantic->componentMask.Content);
@@ -3081,7 +3081,7 @@ struct EmitVisitor
         }
     }
 
-    void visitStructSyntaxNode(RefPtr<StructSyntaxNode> decl, DeclEmitArg const&)
+    void visitStructDecl(RefPtr<StructDecl> decl, DeclEmitArg const&)
     {
         // Don't emit a declaration that was only generated implicitly, for
         // the purposes of semantic checking.
@@ -3106,7 +3106,7 @@ struct EmitVisitor
         auto type = GetType(declRef);
         if (!type || type->As<ErrorType>())
         {
-            EmitType(declRef.getDecl()->Type, declRef.getDecl()->getNameToken());
+            EmitType(declRef.getDecl()->type, declRef.getDecl()->getNameToken());
         }
         else
         {
@@ -3116,9 +3116,9 @@ struct EmitVisitor
         EmitSemantics(declRef.getDecl());
 
         // TODO(tfoley): technically have to apply substitution here too...
-        if (auto initExpr = declRef.getDecl()->Expr)
+        if (auto initExpr = declRef.getDecl()->initExpr)
         {
-            if (declRef.As<ParameterSyntaxNode>()
+            if (declRef.As<ParamDecl>()
                 && context->shared->target == CodeGenTarget::GLSL)
             {
                 // Don't emit default parameter values when lowering to GLSL
@@ -3263,7 +3263,7 @@ struct EmitVisitor
         RefPtr<VarLayout>               layout)
     {
         // The data type that describes where stuff in the constant buffer should go
-        RefPtr<ExpressionType> dataType = parameterBlockType->elementType;
+        RefPtr<Type> dataType = parameterBlockType->elementType;
 
         // We expect/require the data type to be a user-defined `struct` type
         auto declRefType = dataType->As<DeclRefType>();
@@ -3302,7 +3302,7 @@ struct EmitVisitor
         emitHLSLRegisterSemantic(*info);
 
         Emit("\n{\n");
-        if (auto structRef = declRefType->declRef.As<StructSyntaxNode>())
+        if (auto structRef = declRefType->declRef.As<StructDecl>())
         {
             int fieldCounter = 0;
 
@@ -3427,7 +3427,7 @@ struct EmitVisitor
         RefPtr<VarLayout>               layout)
     {
         // The data type that describes where stuff in the constant buffer should go
-        RefPtr<ExpressionType> dataType = parameterBlockType->elementType;
+        RefPtr<Type> dataType = parameterBlockType->elementType;
 
         // We expect/require the data type to be a user-defined `struct` type
         auto declRefType = dataType->As<DeclRefType>();
@@ -3483,7 +3483,7 @@ struct EmitVisitor
         }
 
         Emit("\n{\n");
-        if (auto structRef = declRefType->declRef.As<StructSyntaxNode>())
+        if (auto structRef = declRefType->declRef.As<StructDecl>())
         {
             for (auto field : getMembersOfType<StructField>(structRef))
             {
@@ -3505,7 +3505,7 @@ struct EmitVisitor
         }
         Emit("}");
 
-        if( varDecl->Name.Type != TokenType::Unknown )
+        if( varDecl->Name.type != TokenType::Unknown )
         {
             Emit(" ");
             emitName(varDecl->Name);
@@ -3559,7 +3559,7 @@ struct EmitVisitor
         //
         // TODO(tfoley): there might be a better way to detect this, e.g.,
         // with an attribute that gets attached to the variable declaration.
-        if (auto parameterBlockType = decl->Type->As<ParameterBlockType>())
+        if (auto parameterBlockType = decl->type->As<ParameterBlockType>())
         {
             emitParameterBlockDecl(decl, parameterBlockType, layout);
             return;
@@ -3600,12 +3600,12 @@ struct EmitVisitor
         Emit(";\n");
     }
 
-    void EmitParamDecl(RefPtr<ParameterSyntaxNode> decl)
+    void EmitParamDecl(RefPtr<ParamDecl> decl)
     {
         EmitVarDeclCommon(decl);
     }
 
-    void visitFunctionSyntaxNode(RefPtr<FunctionSyntaxNode> decl, DeclEmitArg const&)
+    void visitFuncDecl(RefPtr<FuncDecl> decl, DeclEmitArg const&)
     {
         EmitModifiers(decl);
 
@@ -3617,7 +3617,7 @@ struct EmitVisitor
 
         Emit("(");
         bool first = true;
-        for (auto paramDecl : decl->getMembersOfType<ParameterSyntaxNode>())
+        for (auto paramDecl : decl->getMembersOfType<ParamDecl>())
         {
             if (!first) Emit(", ");
             EmitParamDecl(paramDecl);
@@ -3638,7 +3638,7 @@ struct EmitVisitor
     }
 
     void emitGLSLVersionDirective(
-        ProgramSyntaxNode*  program)
+        ModuleDecl*  program)
     {
         // Did the user provide an explicit `#version` directive in their code?
         if( auto versionDirective = program->FindModifier<GLSLVersionDirective>() )
@@ -3647,7 +3647,7 @@ struct EmitVisitor
 
             Emit("#version ");
             emit(versionDirective->versionNumberToken.Content);
-            if(versionDirective->glslProfileToken.Type != TokenType::Unknown)
+            if(versionDirective->glslProfileToken.type != TokenType::Unknown)
             {
                 Emit(" ");
                 emit(versionDirective->glslProfileToken.Content);
@@ -3700,7 +3700,7 @@ struct EmitVisitor
     }
 
     void emitGLSLPreprocessorDirectives(
-        RefPtr<ProgramSyntaxNode>   program)
+        RefPtr<ModuleDecl>   program)
     {
         switch(context->shared->target)
         {
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()
diff --git a/source/slang/lexer.cpp b/source/slang/lexer.cpp
index 49856c1c9..84b34c9a9 100644
--- a/source/slang/lexer.cpp
+++ b/source/slang/lexer.cpp
@@ -18,7 +18,7 @@ namespace Slang
     Token* TokenList::end() const
     {
         SLANG_ASSERT(mTokens.Count());
-        SLANG_ASSERT(mTokens[mTokens.Count()-1].Type == TokenType::EndOfFile);
+        SLANG_ASSERT(mTokens[mTokens.Count()-1].type == TokenType::EndOfFile);
         return &mTokens[mTokens.Count() - 1];
     }
 
@@ -40,7 +40,7 @@ namespace Slang
 
         Token token = *mCursor;
         if (mCursor == mEnd)
-            token.Type = TokenType::EndOfFile;
+            token.type = TokenType::EndOfFile;
         return token;
     }
 
@@ -49,7 +49,7 @@ namespace Slang
         if (mCursor == mEnd)
             return TokenType::EndOfFile;
         SLANG_ASSERT(mCursor);
-        return mCursor->Type;
+        return mCursor->type;
     }
 
     CodePosition TokenReader::PeekLoc() const
@@ -67,7 +67,7 @@ namespace Slang
 
         Token token = *mCursor;
         if (mCursor == mEnd)
-            token.Type = TokenType::EndOfFile;
+            token.type = TokenType::EndOfFile;
         else
             mCursor++;
         return token;
@@ -774,8 +774,8 @@ namespace Slang
 
     String getStringLiteralTokenValue(Token const& token)
     {
-        SLANG_ASSERT(token.Type == TokenType::StringLiteral
-            || token.Type == TokenType::CharLiteral);
+        SLANG_ASSERT(token.type == TokenType::StringLiteral
+            || token.type == TokenType::CharLiteral);
 
         char const* cursor = token.Content.begin();
         char const* end = token.Content.end();
@@ -1244,7 +1244,7 @@ namespace Slang
                 break;
             }
 
-            token.Type =  tokenType;
+            token.type =  tokenType;
 
             char const* textEnd = cursor;
 
@@ -1303,7 +1303,7 @@ namespace Slang
             Token token = lexToken();
             tokenList.mTokens.Add(token);
 
-            if(token.Type == TokenType::EndOfFile)
+            if(token.type == TokenType::EndOfFile)
                 return tokenList;
         }
     }
diff --git a/source/slang/lookup.cpp b/source/slang/lookup.cpp
index b0e9ce971..3370b369b 100644
--- a/source/slang/lookup.cpp
+++ b/source/slang/lookup.cpp
@@ -8,7 +8,7 @@ namespace Slang {
 DeclRef<ExtensionDecl> ApplyExtensionToType(
     SemanticsVisitor*       semantics,
     ExtensionDecl*          extDecl,
-    RefPtr<ExpressionType>  type);
+    RefPtr<Type>  type);
 
 //
 
@@ -74,11 +74,11 @@ bool DeclPassesLookupMask(Decl* decl, LookupMask mask)
     // type declarations
     if(auto aggTypeDecl = dynamic_cast<AggTypeDecl*>(decl))
     {
-        return int(mask) & int(LookupMask::Type);
+        return int(mask) & int(LookupMask::type);
     }
     else if(auto simpleTypeDecl = dynamic_cast<SimpleTypeDecl*>(decl))
     {
-        return int(mask) & int(LookupMask::Type);
+        return int(mask) & int(LookupMask::type);
     }
     // function declarations
     else if(auto funcDecl = dynamic_cast<FunctionDeclBase*>(decl))
@@ -154,7 +154,7 @@ LookupResultItem CreateLookupResultItem(
 void DoMemberLookupImpl(
     Session*                session,
     String const&			name,
-    RefPtr<ExpressionType>	baseType,
+    RefPtr<Type>	baseType,
     LookupRequest const&    request,
     LookupResult&			ioResult,
     BreadcrumbInfo*			breadcrumbs)
@@ -270,7 +270,7 @@ void DoLocalLookupImpl(
     // Consider lookup via extension
     if( auto aggTypeDeclRef = containerDeclRef.As<AggTypeDecl>() )
     {
-        RefPtr<ExpressionType> type = DeclRefType::Create(
+        RefPtr<Type> type = DeclRefType::Create(
             session,
             aggTypeDeclRef);
 
diff --git a/source/slang/lookup.h b/source/slang/lookup.h
index 35f378948..8710ac54f 100644
--- a/source/slang/lookup.h
+++ b/source/slang/lookup.h
@@ -38,7 +38,7 @@ QualType getTypeForDeclRef(
     SemanticsVisitor*       sema,
     DiagnosticSink*         sink,
     DeclRef<Decl>           declRef,
-    RefPtr<ExpressionType>* outTypeResult);
+    RefPtr<Type>* outTypeResult);
 
 QualType getTypeForDeclRef(
     Session*        session,
diff --git a/source/slang/lower.cpp b/source/slang/lower.cpp
index e8aa06f03..611180415 100644
--- a/source/slang/lower.cpp
+++ b/source/slang/lower.cpp
@@ -28,7 +28,7 @@ struct StructuralTransformVisitorBase
 {
     V* visitor;
 
-    RefPtr<StatementSyntaxNode> transformDeclField(StatementSyntaxNode* stmt)
+    RefPtr<Stmt> transformDeclField(Stmt* stmt)
     {
         return visitor->translateStmtRef(stmt);
     }
@@ -58,12 +58,12 @@ struct StructuralTransformVisitorBase
         return result;
     }
 
-    RefPtr<ExpressionSyntaxNode> transformSyntaxField(ExpressionSyntaxNode* expr)
+    RefPtr<Expr> transformSyntaxField(Expr* expr)
     {
         return visitor->transformSyntaxField(expr);
     }
 
-    RefPtr<StatementSyntaxNode> transformSyntaxField(StatementSyntaxNode* stmt)
+    RefPtr<Stmt> transformSyntaxField(Stmt* stmt)
     {
         return visitor->transformSyntaxField(stmt);
     }
@@ -92,8 +92,8 @@ struct StructuralTransformVisitorBase
 };
 
 template<typename V>
-RefPtr<StatementSyntaxNode> structuralTransform(
-    StatementSyntaxNode*    stmt,
+RefPtr<Stmt> structuralTransform(
+    Stmt*    stmt,
     V*                      visitor)
 {
     StructuralTransformStmtVisitor<V> transformer;
@@ -104,16 +104,16 @@ RefPtr<StatementSyntaxNode> structuralTransform(
 template<typename V>
 struct StructuralTransformExprVisitor
     : StructuralTransformVisitorBase<V>
-    , ExprVisitor<StructuralTransformExprVisitor<V>, RefPtr<ExpressionSyntaxNode>>
+    , ExprVisitor<StructuralTransformExprVisitor<V>, RefPtr<Expr>>
 {
-    void transformFields(ExpressionSyntaxNode* result, ExpressionSyntaxNode* obj)
+    void transformFields(Expr* result, Expr* obj)
     {
-        result->Type = transformSyntaxField(obj->Type);
+        result->type = transformSyntaxField(obj->type);
     }
 
 
 #define SYNTAX_CLASS(NAME, BASE, ...)                   \
-    RefPtr<ExpressionSyntaxNode> visit##NAME(NAME* obj) {     \
+    RefPtr<Expr> visit##NAME(NAME* obj) {     \
         RefPtr<NAME> result = new NAME(*obj);           \
         transformFields(result, obj);                   \
         return result;                                  \
@@ -136,8 +136,8 @@ struct StructuralTransformExprVisitor
 
 
 template<typename V>
-RefPtr<ExpressionSyntaxNode> structuralTransform(
-    ExpressionSyntaxNode*   expr,
+RefPtr<Expr> structuralTransform(
+    Expr*   expr,
     V*                      visitor)
 {
     StructuralTransformExprVisitor<V> transformer;
@@ -257,7 +257,7 @@ struct LoweredExpr
         : flavor(Flavor::Expr)
     {}
 
-    LoweredExpr(ExpressionSyntaxNode* expr)
+    LoweredExpr(Expr* expr)
         : value(expr)
         , flavor(Flavor::Expr)
     {}
@@ -274,10 +274,10 @@ struct LoweredExpr
 
     Flavor getFlavor() const { return flavor; }
 
-    ExpressionSyntaxNode* getExpr() const
+    Expr* getExpr() const
     {
         assert(getFlavor() == Flavor::Expr);
-        return (ExpressionSyntaxNode*)value.Ptr();
+        return (Expr*)value.Ptr();
     }
 
     TupleExpr* getTupleExpr() const
@@ -293,7 +293,7 @@ struct LoweredExpr
         return (VaryingTupleExpr*)value.Ptr();
     }
 
-    ExpressionSyntaxNode* asExpr() const
+    Expr* asExpr() const
     {
         return (getFlavor() == Flavor::Expr) ? getExpr() : nullptr;
     }
@@ -319,7 +319,7 @@ class PseudoVarDecl : public RefObject
 public:
     Token Name;
     CodePosition Position;
-    TypeExp Type;
+    TypeExp type;
 };
 
 class TupleVarDecl : public PseudoVarDecl
@@ -340,7 +340,7 @@ class PseudoExpr : public RefObject
 {
 public:
     CodePosition Position;
-    QualType Type;
+    QualType type;
 };
 
 // Pseudo-syntax used during lowering:
@@ -356,7 +356,7 @@ public:
 
     // Optional reference to the "primary" value of the tuple,
     // in the case of a tuple type with "orinary" fields
-    RefPtr<ExpressionSyntaxNode>    primaryExpr;
+    RefPtr<Expr>    primaryExpr;
 
     // Additional fields to store values for any non-ordinary fields
     // (or fields that aren't exclusively orginary)
@@ -418,14 +418,14 @@ struct SharedLoweringContext
     Dictionary<String, String> reservedWords;
 
 
-    RefPtr<ProgramSyntaxNode>   loweredProgram;
+    RefPtr<ModuleDecl>   loweredProgram;
 
     Dictionary<Decl*, LoweredDecl> loweredDecls;
     Dictionary<RefObject*, Decl*> mapLoweredDeclToOriginal;
 
     // Work to be done at the very start and end of the entry point
-    RefPtr<StatementSyntaxNode> entryPointInitializeStmt;
-    RefPtr<StatementSyntaxNode> entryPointFinalizeStmt;
+    RefPtr<Stmt> entryPointInitializeStmt;
+    RefPtr<Stmt> entryPointFinalizeStmt;
 
     // Counter used for generating unique temporary names
     int nameCounter = 0;
@@ -452,14 +452,14 @@ struct LoweringVisitor
     : ExprVisitor<LoweringVisitor, LoweredExpr>
     , StmtVisitor<LoweringVisitor, void>
     , DeclVisitor<LoweringVisitor, LoweredDecl>
-    , ValVisitor<LoweringVisitor, RefPtr<Val>, RefPtr<ExpressionType>>
+    , ValVisitor<LoweringVisitor, RefPtr<Val>, RefPtr<Type>>
 {
     //
     SharedLoweringContext*      shared;
     RefPtr<Substitutions>       substitutions;
 
     bool                        isBuildingStmt = false;
-    RefPtr<StatementSyntaxNode> stmtBeingBuilt;
+    RefPtr<Stmt> stmtBeingBuilt;
 
     // If we *aren't* building a statement, then this
     // is the container we should be adding declarations to
@@ -660,8 +660,8 @@ struct LoweringVisitor
     // Types
     //
 
-    RefPtr<ExpressionType> lowerType(
-        ExpressionType* type)
+    RefPtr<Type> lowerType(
+        Type* type)
     {
         if (!type) return nullptr;
         return TypeVisitor::dispatch(type);
@@ -676,29 +676,29 @@ struct LoweringVisitor
         return result;
     }
 
-    RefPtr<ExpressionType> visitErrorType(ErrorType* type)
+    RefPtr<Type> visitErrorType(ErrorType* type)
     {
         return type;
     }
 
-    RefPtr<ExpressionType> visitOverloadGroupType(OverloadGroupType* type)
+    RefPtr<Type> visitOverloadGroupType(OverloadGroupType* type)
     {
         return type;
     }
 
-    RefPtr<ExpressionType> visitInitializerListType(InitializerListType* type)
+    RefPtr<Type> visitInitializerListType(InitializerListType* type)
     {
         return type;
     }
 
-    RefPtr<ExpressionType> visitGenericDeclRefType(GenericDeclRefType* type)
+    RefPtr<Type> visitGenericDeclRefType(GenericDeclRefType* type)
     {
         return getGenericDeclRefType(
             type->getSession(),
             translateDeclRef(DeclRef<Decl>(type->declRef)).As<GenericDecl>());
     }
 
-    RefPtr<ExpressionType> visitFuncType(FuncType* type)
+    RefPtr<Type> visitFuncType(FuncType* type)
     {
         RefPtr<FuncType> loweredType = getFuncType(
             getSession(),
@@ -706,7 +706,7 @@ struct LoweringVisitor
         return loweredType;
     }
 
-    RefPtr<ExpressionType> visitDeclRefType(DeclRefType* type)
+    RefPtr<Type> visitDeclRefType(DeclRefType* type)
     {
         auto loweredDeclRef = translateDeclRef(type->declRef);
         return DeclRefType::Create(
@@ -714,7 +714,7 @@ struct LoweringVisitor
             loweredDeclRef.As<Decl>());
     }
 
-    RefPtr<ExpressionType> visitNamedExpressionType(NamedExpressionType* type)
+    RefPtr<Type> visitNamedExpressionType(NamedExpressionType* type)
     {
         if (shared->target == CodeGenTarget::GLSL)
         {
@@ -727,12 +727,12 @@ struct LoweringVisitor
             translateDeclRef(DeclRef<Decl>(type->declRef)).As<TypeDefDecl>());
     }
 
-    RefPtr<ExpressionType> visitTypeType(TypeType* type)
+    RefPtr<Type> visitTypeType(TypeType* type)
     {
         return getTypeType(lowerType(type->type));
     }
 
-    RefPtr<ExpressionType> visitArrayExpressionType(ArrayExpressionType* type)
+    RefPtr<Type> visitArrayExpressionType(ArrayExpressionType* type)
     {
         RefPtr<ArrayExpressionType> loweredType = Slang::getArrayType(
             lowerType(type->BaseType),
@@ -740,7 +740,7 @@ struct LoweringVisitor
         return loweredType;
     }
 
-    RefPtr<ExpressionType> transformSyntaxField(ExpressionType* type)
+    RefPtr<Type> transformSyntaxField(Type* type)
     {
         return lowerType(type);
     }
@@ -750,14 +750,14 @@ struct LoweringVisitor
     //
 
     LoweredExpr lowerExprOrTuple(
-        ExpressionSyntaxNode* expr)
+        Expr* expr)
     {
         if (!expr) return LoweredExpr();
         return ExprVisitor::dispatch(expr);
     }
 
-    RefPtr<ExpressionSyntaxNode> lowerExpr(
-        ExpressionSyntaxNode* expr)
+    RefPtr<Expr> lowerExpr(
+        Expr* expr)
     {
         if (!expr) return nullptr;
 
@@ -766,28 +766,28 @@ struct LoweringVisitor
     }
 
     // catch-all
-    RefPtr<ExpressionSyntaxNode> visitExpressionSyntaxNode(
-        ExpressionSyntaxNode* expr)
+    LoweredExpr visitExpr(
+        Expr* expr)
     {
-        return structuralTransform(expr, this);
+        return LoweredExpr(structuralTransform(expr, this));
     }
 
-    RefPtr<ExpressionSyntaxNode> transformSyntaxField(ExpressionSyntaxNode* expr)
+    RefPtr<Expr> transformSyntaxField(Expr* expr)
     {
         return lowerExpr(expr);
     }
 
     void lowerExprCommon(
-        ExpressionSyntaxNode*    loweredExpr,
-        ExpressionSyntaxNode*    expr)
+        Expr*    loweredExpr,
+        Expr*    expr)
     {
         loweredExpr->Position = expr->Position;
-        loweredExpr->Type.type = lowerType(expr->Type.type);
+        loweredExpr->type.type = lowerType(expr->type.type);
     }
 
     void lowerExprCommon(
         LoweredExpr const&      loweredExpr,
-        ExpressionSyntaxNode*   expr)
+        Expr*   expr)
     {
         if (auto simpleExpr = loweredExpr.asExpr())
         {
@@ -795,21 +795,21 @@ struct LoweringVisitor
         }
     }
 
-    RefPtr<ExpressionSyntaxNode> createUncheckedVarRef(
+    RefPtr<Expr> createUncheckedVarRef(
         char const* name)
     {
-        RefPtr<VarExpressionSyntaxNode> result = new VarExpressionSyntaxNode();
+        RefPtr<VarExpr> result = new VarExpr();
         result->name = name;
         return result;
     }
 
-    RefPtr<ExpressionSyntaxNode> createSimpleVarRef(
+    RefPtr<Expr> createSimpleVarRef(
         CodePosition const& loc,
         VarDeclBase*        decl)
     {
-        RefPtr<VarExpressionSyntaxNode> result = new VarExpressionSyntaxNode();
+        RefPtr<VarExpr> result = new VarExpr();
         result->Position = loc;
-        result->Type.type = decl->Type.type;
+        result->type.type = decl->type.type;
         result->declRef = makeDeclRef(decl);
         result->name = decl->getName();
         return result;
@@ -843,7 +843,7 @@ struct LoweringVisitor
     {
         RefPtr<TupleExpr> result = new TupleExpr();
         result->Position = loc;
-        result->Type.type = decl->Type.type;
+        result->type.type = decl->type.type;
 
         if (auto primaryDecl = decl->primaryDecl)
         {
@@ -874,8 +874,8 @@ struct LoweringVisitor
         return decl->expr;
     }
 
-    LoweredExpr visitVarExpressionSyntaxNode(
-        VarExpressionSyntaxNode* expr)
+    LoweredExpr visitVarExpr(
+        VarExpr* expr)
     {
         doSampleRateInputCheck(expr->name);
 
@@ -898,7 +898,7 @@ struct LoweringVisitor
             return createVaryingTupleRef(expr->Position, varyingTupleVarDecl);
         }
 
-        RefPtr<VarExpressionSyntaxNode> loweredExpr = new VarExpressionSyntaxNode();
+        RefPtr<VarExpr> loweredExpr = new VarExpr();
         lowerExprCommon(loweredExpr, expr);
         loweredExpr->declRef = loweredDeclRef.As<Decl>();
         loweredExpr->name = expr->name;
@@ -915,12 +915,12 @@ struct LoweringVisitor
         return result;
     }
 
-    RefPtr<ExpressionSyntaxNode> moveTemp(RefPtr<ExpressionSyntaxNode> expr)
+    RefPtr<Expr> moveTemp(RefPtr<Expr> expr)
     {
         RefPtr<Variable> varDecl = new Variable();
         varDecl->Name.Content = generateName();
-        varDecl->Type.type = expr->Type.type;
-        varDecl->Expr = expr;
+        varDecl->type.type = expr->type.type;
+        varDecl->initExpr = expr;
 
         addDecl(varDecl);
 
@@ -931,16 +931,16 @@ struct LoweringVisitor
     // use/evaluate more than once, and if needed replace it with a
     // reference to a temporary (initialized with the expr) so that it
     // can safely be re-evaluated.
-    RefPtr<ExpressionSyntaxNode> maybeMoveTemp(
-        ExpressionSyntaxNode* expr)
+    RefPtr<Expr> maybeMoveTemp(
+        Expr* expr)
     {
         // TODO: actually implement this properly!
 
         // Certain expressions are already in a form we can directly re-use,
         // so  there is no reason to move them.
-        if (dynamic_cast<VarExpressionSyntaxNode*>(expr))
+        if (dynamic_cast<VarExpr*>(expr))
             return expr;
-        if (dynamic_cast<ConstantExpressionSyntaxNode*>(expr))
+        if (dynamic_cast<ConstantExpr*>(expr))
             return expr;
 
         // In the general case, though, we need to introduce a temporary
@@ -954,7 +954,7 @@ struct LoweringVisitor
         {
             RefPtr<TupleExpr> resultExpr = new TupleExpr();
             resultExpr->Position = tupleExpr->Position;
-            resultExpr->Type = tupleExpr->Type;
+            resultExpr->type = tupleExpr->type;
             if (tupleExpr->primaryExpr)
             {
                 resultExpr->primaryExpr = maybeMoveTemp(tupleExpr->primaryExpr);
@@ -974,7 +974,7 @@ struct LoweringVisitor
         {
             RefPtr<VaryingTupleExpr> resultExpr = new VaryingTupleExpr();
             resultExpr->Position = varyingTupleExpr->Position;
-            resultExpr->Type = varyingTupleExpr->Type;
+            resultExpr->type = varyingTupleExpr->type;
             for (auto ee : varyingTupleExpr->elements)
             {
                 VaryingTupleExpr::Element elem;
@@ -995,8 +995,8 @@ struct LoweringVisitor
     // Similar to the above, this ensures that an l-value expression
     // is safe to re-evaluate, by recursively moving things off
     // to temporaries where needed.
-    RefPtr<ExpressionSyntaxNode> ensureSimpleLValue(
-        ExpressionSyntaxNode* expr)
+    RefPtr<Expr> ensureSimpleLValue(
+        Expr* expr)
     {
         // TODO: actually implement this properly!
 
@@ -1021,22 +1021,22 @@ struct LoweringVisitor
         WithFixups,
     };
 
-    RefPtr<ExpressionSyntaxNode> createSimpleAssignExpr(
-        RefPtr<ExpressionSyntaxNode>    leftExpr,
-        RefPtr<ExpressionSyntaxNode>    rightExpr)
+    RefPtr<Expr> createSimpleAssignExpr(
+        RefPtr<Expr>    leftExpr,
+        RefPtr<Expr>    rightExpr)
     {
         RefPtr<AssignExpr> loweredExpr = new AssignExpr();
-        loweredExpr->Type = leftExpr->Type;
+        loweredExpr->type = leftExpr->type;
         loweredExpr->left = leftExpr;
         loweredExpr->right = rightExpr;
         return loweredExpr;
     }
 
-    RefPtr<ExpressionSyntaxNode> convertExprForAssignmentWithFixups(
-        RefPtr<ExpressionType>          leftType,
-        RefPtr<ExpressionSyntaxNode>    rightExpr)
+    RefPtr<Expr> convertExprForAssignmentWithFixups(
+        RefPtr<Type>          leftType,
+        RefPtr<Expr>    rightExpr)
     {
-        auto rightType = rightExpr->Type.type;
+        auto rightType = rightExpr->type.type;
         if (auto leftArrayType = leftType->As<ArrayExpressionType>())
         {
             // LHS type was an array
@@ -1058,7 +1058,7 @@ struct LoweringVisitor
 
                     RefPtr<AggTypeCtorExpr> ctorExpr = new AggTypeCtorExpr();
                     ctorExpr->Position = rightExpr->Position;
-                    ctorExpr->Type.type = leftType;
+                    ctorExpr->type.type = leftType;
                     ctorExpr->base.type = leftType;
 
                     int elementCount = (int) GetIntVal(rightVecType->elementCount);
@@ -1066,7 +1066,7 @@ struct LoweringVisitor
                     {
                         RefPtr<SwizzleExpr> swizzleExpr = new SwizzleExpr();
                         swizzleExpr->Position = rightExpr->Position;
-                        swizzleExpr->Type.type = rightVecType->elementType;
+                        swizzleExpr->type.type = rightVecType->elementType;
                         swizzleExpr->base = rightExpr;
                         swizzleExpr->elementCount = 1;
                         swizzleExpr->elementIndices[0] = ee;
@@ -1089,42 +1089,42 @@ struct LoweringVisitor
 
     }
 
-    RefPtr<ExpressionSyntaxNode> createConstIntExpr(IntegerLiteralValue value)
+    RefPtr<Expr> createConstIntExpr(IntegerLiteralValue value)
     {
-        RefPtr<ConstantExpressionSyntaxNode> expr = new ConstantExpressionSyntaxNode();
-        expr->Type.type = getIntType();
-        expr->ConstType = ConstantExpressionSyntaxNode::ConstantType::Int;
+        RefPtr<ConstantExpr> expr = new ConstantExpr();
+        expr->type.type = getIntType();
+        expr->ConstType = ConstantExpr::ConstantType::Int;
         expr->integerValue = value;
         return expr;
     }
 
     struct SeqExprBuilder
     {
-        RefPtr<ExpressionSyntaxNode> expr;
-        RefPtr<ExpressionSyntaxNode>* link = nullptr;
+        RefPtr<Expr> expr;
+        RefPtr<Expr>* link = nullptr;
     };
 
-    RefPtr<ExpressionSyntaxNode> createSimpleVarExpr(char const* name)
+    RefPtr<Expr> createSimpleVarExpr(char const* name)
     {
-        RefPtr<VarExpressionSyntaxNode> varExpr = new VarExpressionSyntaxNode();
+        RefPtr<VarExpr> varExpr = new VarExpr();
         varExpr->name = name;
         return varExpr;
     }
 
-    RefPtr<InvokeExpressionSyntaxNode> createSeqExpr(
-        RefPtr<ExpressionSyntaxNode>    left,
-        RefPtr<ExpressionSyntaxNode>    right)
+    RefPtr<InvokeExpr> createSeqExpr(
+        RefPtr<Expr>    left,
+        RefPtr<Expr>    right)
     {
         RefPtr<InfixExpr> seqExpr = new InfixExpr();
         seqExpr->Position = left->Position;
-        seqExpr->Type = right->Type;
+        seqExpr->type = right->type;
         seqExpr->FunctionExpr = createSimpleVarExpr(",");
         seqExpr->Arguments.Add(left);
         seqExpr->Arguments.Add(right);
         return seqExpr;
     }
 
-    void addExpr(SeqExprBuilder* builder, RefPtr<ExpressionSyntaxNode> expr)
+    void addExpr(SeqExprBuilder* builder, RefPtr<Expr> expr)
     {
         // No expression to add? Do nothing.
         if (!expr) return;
@@ -1159,12 +1159,12 @@ struct LoweringVisitor
         builder->link = &seqExpr->Arguments[1];
     }
 
-    RefPtr<ExpressionSyntaxNode> createSimpleAssignExprWithFixups(
-        RefPtr<ExpressionSyntaxNode>    leftExpr,
-        RefPtr<ExpressionSyntaxNode>    rightExpr)
+    RefPtr<Expr> createSimpleAssignExprWithFixups(
+        RefPtr<Expr>    leftExpr,
+        RefPtr<Expr>    rightExpr)
     {
-        auto leftType = leftExpr->Type.type;
-        auto rightType = rightExpr->Type.type;
+        auto leftType = leftExpr->type.type;
+        auto rightType = rightExpr->type.type;
 
         // If types are unknown, or match, then just do
         // things the ordinary way.
@@ -1206,16 +1206,16 @@ struct LoweringVisitor
                     for (int ee = 0; ee < elementCount; ++ee)
                     {
                         // LHS array element
-                        RefPtr<IndexExpressionSyntaxNode> arrayElemExpr = new IndexExpressionSyntaxNode();
+                        RefPtr<IndexExpr> arrayElemExpr = new IndexExpr();
                         arrayElemExpr->Position = leftExpr->Position;
-                        arrayElemExpr->Type.type = leftArrayType->BaseType;
+                        arrayElemExpr->type.type = leftArrayType->BaseType;
                         arrayElemExpr->BaseExpression = leftExpr;
                         arrayElemExpr->IndexExpression = createConstIntExpr(ee);
 
                         // RHS swizzle
                         RefPtr<SwizzleExpr> swizzleExpr = new SwizzleExpr();
                         swizzleExpr->Position = rightExpr->Position;
-                        swizzleExpr->Type.type = rightVecType->elementType;
+                        swizzleExpr->type.type = rightVecType->elementType;
                         swizzleExpr->base = rightExpr;
                         swizzleExpr->elementCount = 1;
                         swizzleExpr->elementIndices[0] = ee;
@@ -1243,9 +1243,9 @@ struct LoweringVisitor
         return createSimpleAssignExpr(leftExpr, convertedRightExpr);
     }
 
-    RefPtr<ExpressionSyntaxNode> createSimpleAssignExpr(
-        ExpressionSyntaxNode*   leftExpr,
-        ExpressionSyntaxNode*   rightExpr,
+    RefPtr<Expr> createSimpleAssignExpr(
+        Expr*   leftExpr,
+        Expr*   rightExpr,
         AssignMode              mode)
     {
         switch (mode)
@@ -1268,7 +1268,7 @@ struct LoweringVisitor
         if (leftTuple && rightTuple)
         {
             RefPtr<TupleExpr> resultTuple = new TupleExpr();
-            resultTuple->Type = leftTuple->Type;
+            resultTuple->type = leftTuple->type;
 
             if (leftTuple->primaryExpr)
             {
@@ -1308,16 +1308,16 @@ struct LoweringVisitor
         auto leftVaryingTuple = leftExpr.asVaryingTuple();
         auto rightVaryingTuple = rightExpr.asVaryingTuple();
 
-        RefPtr<ExpressionSyntaxNode> leftSimpleExpr = leftExpr.asExpr();
-        RefPtr<ExpressionSyntaxNode> rightSimpleExpr = rightExpr.asExpr();
+        RefPtr<Expr> leftSimpleExpr = leftExpr.asExpr();
+        RefPtr<Expr> rightSimpleExpr = rightExpr.asExpr();
 
         if (leftVaryingTuple && rightVaryingTuple)
         {
             RefPtr<VaryingTupleExpr> resultTuple = new VaryingTupleExpr();
-            resultTuple->Type.type = leftVaryingTuple->Type.type;
+            resultTuple->type.type = leftVaryingTuple->type.type;
             resultTuple->Position = leftVaryingTuple->Position;
 
-            SLANG_RELEASE_ASSERT(resultTuple->Type.type);
+            SLANG_RELEASE_ASSERT(resultTuple->type.type);
 
             UInt elementCount = leftVaryingTuple->elements.Count();
             SLANG_RELEASE_ASSERT(elementCount == rightVaryingTuple->elements.Count());
@@ -1343,10 +1343,10 @@ struct LoweringVisitor
             // This will naturally yield a tuple expression.
 
             RefPtr<VaryingTupleExpr> resultTuple = new VaryingTupleExpr();
-            resultTuple->Type.type = leftVaryingTuple->Type.type;
+            resultTuple->type.type = leftVaryingTuple->type.type;
             resultTuple->Position = leftVaryingTuple->Position;
 
-            SLANG_RELEASE_ASSERT(resultTuple->Type.type);
+            SLANG_RELEASE_ASSERT(resultTuple->type.type);
 
             UInt elementCount = leftVaryingTuple->elements.Count();
 
@@ -1365,9 +1365,9 @@ struct LoweringVisitor
                 auto leftElem = leftVaryingTuple->elements[ee];
 
 
-                RefPtr<MemberExpressionSyntaxNode> rightElemExpr = new MemberExpressionSyntaxNode();
+                RefPtr<MemberExpr> rightElemExpr = new MemberExpr();
                 rightElemExpr->Position = rightSimpleExpr->Position;
-                rightElemExpr->Type.type = GetType(leftElem.originalFieldDeclRef);
+                rightElemExpr->type.type = GetType(leftElem.originalFieldDeclRef);
                 rightElemExpr->declRef = leftElem.originalFieldDeclRef;
                 rightElemExpr->name = leftElem.originalFieldDeclRef.GetName();
                 rightElemExpr->BaseExpression = rightSimpleExpr;
@@ -1391,10 +1391,10 @@ struct LoweringVisitor
 
 
             RefPtr<VaryingTupleExpr> resultTuple = new VaryingTupleExpr();
-            resultTuple->Type.type = leftSimpleExpr->Type.type;
+            resultTuple->type.type = leftSimpleExpr->type.type;
             resultTuple->Position = leftSimpleExpr->Position;
 
-            SLANG_RELEASE_ASSERT(resultTuple->Type.type);
+            SLANG_RELEASE_ASSERT(resultTuple->type.type);
 
             UInt elementCount = rightVaryingTuple->elements.Count();
 
@@ -1412,9 +1412,9 @@ struct LoweringVisitor
                 auto rightElem = rightVaryingTuple->elements[ee];
 
 
-                RefPtr<MemberExpressionSyntaxNode> leftElemExpr = new MemberExpressionSyntaxNode();
+                RefPtr<MemberExpr> leftElemExpr = new MemberExpr();
                 leftElemExpr->Position = leftSimpleExpr->Position;
-                leftElemExpr->Type.type = GetType(rightElem.originalFieldDeclRef);
+                leftElemExpr->type.type = GetType(rightElem.originalFieldDeclRef);
                 leftElemExpr->declRef = rightElem.originalFieldDeclRef;
                 leftElemExpr->name = rightElem.originalFieldDeclRef.GetName();
                 leftElemExpr->BaseExpression = leftSimpleExpr;
@@ -1455,8 +1455,8 @@ struct LoweringVisitor
         return loweredExpr;
     }
 
-    RefPtr<ExpressionType> getSubscripResultType(
-        RefPtr<ExpressionType>  type)
+    RefPtr<Type> getSubscripResultType(
+        RefPtr<Type>  type)
     {
         if (auto arrayType = type->As<ArrayExpressionType>())
         {
@@ -1465,14 +1465,14 @@ struct LoweringVisitor
         return nullptr;
     }
 
-    RefPtr<ExpressionSyntaxNode> createSimpleSubscriptExpr(
-        RefPtr<ExpressionSyntaxNode>    baseExpr,
-        RefPtr<ExpressionSyntaxNode>    indexExpr)
+    RefPtr<Expr> createSimpleSubscriptExpr(
+        RefPtr<Expr>    baseExpr,
+        RefPtr<Expr>    indexExpr)
     {
         // Default case: just reconstrut a subscript expr
-        auto loweredExpr = new IndexExpressionSyntaxNode();
+        auto loweredExpr = new IndexExpr();
 
-        loweredExpr->Type.type = getSubscripResultType(baseExpr->Type.type);
+        loweredExpr->type.type = getSubscripResultType(baseExpr->type.type);
 
         loweredExpr->BaseExpression = baseExpr;
         loweredExpr->IndexExpression = indexExpr;
@@ -1481,7 +1481,7 @@ struct LoweringVisitor
 
     LoweredExpr createSubscriptExpr(
         LoweredExpr                     baseExpr,
-        RefPtr<ExpressionSyntaxNode>    indexExpr)
+        RefPtr<Expr>    indexExpr)
     {
         // TODO: This logic ends up duplicating the `indexExpr`
         // that was given, without worrying about any side
@@ -1492,7 +1492,7 @@ struct LoweringVisitor
             indexExpr = maybeMoveTemp(indexExpr);
 
             auto loweredExpr = new TupleExpr();
-            loweredExpr->Type.type = getSubscripResultType(baseTuple->Type.type);
+            loweredExpr->type.type = getSubscripResultType(baseTuple->type.type);
 
             if (auto basePrimary = baseTuple->primaryExpr)
             {
@@ -1518,9 +1518,9 @@ struct LoweringVisitor
             indexExpr = maybeMoveTemp(indexExpr);
 
             auto loweredExpr = new VaryingTupleExpr();
-            loweredExpr->Type.type = getSubscripResultType(baseVaryingTuple->Type.type);
+            loweredExpr->type.type = getSubscripResultType(baseVaryingTuple->type.type);
 
-            SLANG_RELEASE_ASSERT(loweredExpr->Type.type);
+            SLANG_RELEASE_ASSERT(loweredExpr->type.type);
 
             for (auto elem : baseVaryingTuple->elements)
             {
@@ -1541,8 +1541,8 @@ struct LoweringVisitor
         }
     }
 
-    LoweredExpr visitIndexExpressionSyntaxNode(
-        IndexExpressionSyntaxNode* subscriptExpr)
+    LoweredExpr visitIndexExpr(
+        IndexExpr* subscriptExpr)
     {
         auto baseExpr = lowerExprOrTuple(subscriptExpr->BaseExpression);
         auto indexExpr = lowerExpr(subscriptExpr->IndexExpression);
@@ -1560,7 +1560,7 @@ struct LoweringVisitor
         else
         {
             // Default case: just reconstrut a subscript expr
-            RefPtr<IndexExpressionSyntaxNode> loweredExpr = new IndexExpressionSyntaxNode();
+            RefPtr<IndexExpr> loweredExpr = new IndexExpr();
             lowerExprCommon(loweredExpr, subscriptExpr);
             loweredExpr->BaseExpression = baseExpr.getExpr();
             loweredExpr->IndexExpression = indexExpr;
@@ -1568,7 +1568,7 @@ struct LoweringVisitor
         }
     }
 
-    RefPtr<ExpressionSyntaxNode> maybeReifyTuple(
+    RefPtr<Expr> maybeReifyTuple(
         LoweredExpr expr)
     {
         if (auto tupleExpr = expr.asTuple())
@@ -1586,9 +1586,9 @@ struct LoweringVisitor
             // to handle that case...
 
             RefPtr<AggTypeCtorExpr> resultExpr = new AggTypeCtorExpr();
-            resultExpr->Type = varyingTupleExpr->Type;
-            resultExpr->base.type = varyingTupleExpr->Type.type;
-            SLANG_RELEASE_ASSERT(resultExpr->Type.type);
+            resultExpr->type = varyingTupleExpr->type;
+            resultExpr->base.type = varyingTupleExpr->type.type;
+            SLANG_RELEASE_ASSERT(resultExpr->type.type);
 
             for (auto elem : varyingTupleExpr->elements)
             {
@@ -1603,7 +1603,7 @@ struct LoweringVisitor
     }
 
     bool needGlslangBug988Workaround(
-        RefPtr<ExpressionSyntaxNode> inExpr)
+        RefPtr<Expr> inExpr)
     {
         switch (getTarget())
         {
@@ -1622,7 +1622,7 @@ struct LoweringVisitor
 
         // Issue (1): is the type of the expression something that needs the WAR?
 
-        auto exprType = inExpr->Type.type;
+        auto exprType = inExpr->type.type;
         exprType = unwrapArray(exprType);
 
         if (!isStructType(exprType))
@@ -1634,7 +1634,7 @@ struct LoweringVisitor
         auto expr = inExpr;
         for (;;)
         {
-            if (auto memberRefExpr = expr.As<MemberExpressionSyntaxNode>())
+            if (auto memberRefExpr = expr.As<MemberExpr>())
             {
                 expr = memberRefExpr->BaseExpression;
                 continue;
@@ -1646,7 +1646,7 @@ struct LoweringVisitor
                 continue;
             }
 
-            if (auto subscriptExpr = expr.As<IndexExpressionSyntaxNode>())
+            if (auto subscriptExpr = expr.As<IndexExpr>())
             {
                 expr = subscriptExpr->BaseExpression;
                 continue;
@@ -1655,7 +1655,7 @@ struct LoweringVisitor
             break;
         }
 
-        if (auto varExpr = expr.As<VarExpressionSyntaxNode>())
+        if (auto varExpr = expr.As<VarExpr>())
         {
             auto declRef = varExpr->declRef;
             if (!declRef)
@@ -1682,7 +1682,7 @@ struct LoweringVisitor
 
     void addArg(
         ExprWithArgsBase*               callExpr,
-        RefPtr<ExpressionSyntaxNode>    argExpr)
+        RefPtr<Expr>    argExpr)
     {
         // This should be the default case where we have a perfectly
         // ordinary expression, but we need to work around a glslang
@@ -1726,9 +1726,9 @@ struct LoweringVisitor
         }
     }
 
-    RefPtr<ExpressionSyntaxNode> lowerCallExpr(
-        RefPtr<InvokeExpressionSyntaxNode>  loweredExpr,
-        InvokeExpressionSyntaxNode*         expr)
+    RefPtr<Expr> lowerCallExpr(
+        RefPtr<InvokeExpr>  loweredExpr,
+        InvokeExpr*         expr)
     {
         lowerExprCommon(loweredExpr, expr);
 
@@ -1743,10 +1743,10 @@ struct LoweringVisitor
         return loweredExpr;
     }
 
-    LoweredExpr visitInvokeExpressionSyntaxNode(
-        InvokeExpressionSyntaxNode* expr)
+    LoweredExpr visitInvokeExpr(
+        InvokeExpr* expr)
     {
-        return LoweredExpr(lowerCallExpr(new InvokeExpressionSyntaxNode(), expr));
+        return LoweredExpr(lowerCallExpr(new InvokeExpr(), expr));
     }
 
     LoweredExpr visitInfixExpr(
@@ -1761,12 +1761,12 @@ struct LoweringVisitor
         return LoweredExpr(lowerCallExpr(new PrefixExpr(), expr));
     }
 
-    LoweredExpr visitSelectExpressionSyntaxNode(
-        SelectExpressionSyntaxNode* expr)
+    LoweredExpr visitSelectExpr(
+        SelectExpr* expr)
     {
         // TODO: A tuple needs to be special-cased here
 
-        return LoweredExpr(lowerCallExpr(new SelectExpressionSyntaxNode(), expr));
+        return LoweredExpr(lowerCallExpr(new SelectExpr(), expr));
     }
 
     LoweredExpr visitPostfixExpr(
@@ -1827,8 +1827,8 @@ struct LoweringVisitor
         return &shared->compileRequest->mSink;
     }
 
-    LoweredExpr visitMemberExpressionSyntaxNode(
-        MemberExpressionSyntaxNode* expr)
+    LoweredExpr visitMemberExpr(
+        MemberExpr* expr)
     {
         auto loweredBase = lowerExprOrTuple(expr->BaseExpression);
 
@@ -1862,7 +1862,7 @@ struct LoweringVisitor
                 SLANG_RELEASE_ASSERT(!tupleFieldTupleExpr->primaryExpr);
 
 
-                RefPtr<MemberExpressionSyntaxNode> loweredPrimaryExpr = new MemberExpressionSyntaxNode();
+                RefPtr<MemberExpr> loweredPrimaryExpr = new MemberExpr();
                 lowerExprCommon(loweredPrimaryExpr, expr);
                 loweredPrimaryExpr->BaseExpression = baseTuple->primaryExpr;
                 loweredPrimaryExpr->declRef = loweredDeclRef.As<Decl>();
@@ -1893,7 +1893,7 @@ struct LoweringVisitor
 
         // Default handling:
 
-        RefPtr<MemberExpressionSyntaxNode> loweredExpr = new MemberExpressionSyntaxNode();
+        RefPtr<MemberExpr> loweredExpr = new MemberExpr();
         lowerExprCommon(loweredExpr, expr);
         loweredExpr->BaseExpression = loweredBase.getExpr();
         loweredExpr->declRef = loweredDeclRef.As<Decl>();
@@ -1911,8 +1911,8 @@ struct LoweringVisitor
     // (or event to none), and in such a case this function wraps
     // the result up as a `SeqStmt` or `EmptyStmt` as appropriate.
     //
-    RefPtr<StatementSyntaxNode> lowerStmt(
-        StatementSyntaxNode* stmt)
+    RefPtr<Stmt> lowerStmt(
+        Stmt* stmt)
     {
         if (!stmt)
             return nullptr;
@@ -1924,7 +1924,7 @@ struct LoweringVisitor
 
         if (!subVisitor.stmtBeingBuilt)
         {
-            return new EmptyStatementSyntaxNode();
+            return new EmptyStmt();
         }
         else
         {
@@ -1940,14 +1940,14 @@ struct LoweringVisitor
         StmtLoweringState*      parent = nullptr;
 
         // The outer statement (both lowered and original)
-        StatementSyntaxNode*    loweredStmt = nullptr;
-        StatementSyntaxNode*    originalStmt = nullptr;
+        Stmt*    loweredStmt = nullptr;
+        Stmt*    originalStmt = nullptr;
     };
     StmtLoweringState stmtLoweringState;
 
     // Translate a reference from one statement to an outer statement
-    StatementSyntaxNode* translateStmtRef(
-        StatementSyntaxNode* originalStmt)
+    Stmt* translateStmtRef(
+        Stmt* originalStmt)
     {
         if (!originalStmt) return nullptr;
 
@@ -1964,7 +1964,7 @@ struct LoweringVisitor
 
     // Expand a statement to be lowered into one or more statements
     void lowerStmtImpl(
-        StatementSyntaxNode* stmt)
+        Stmt* stmt)
     {
         StmtVisitor::dispatch(stmt);
     }
@@ -1993,8 +1993,8 @@ struct LoweringVisitor
     }
 
     void addStmtImpl(
-        RefPtr<StatementSyntaxNode>&    dest,
-        StatementSyntaxNode*            stmt)
+        RefPtr<Stmt>&    dest,
+        Stmt*            stmt)
     {
         // add a statement to the code we are building...
         if (!dest)
@@ -2026,17 +2026,17 @@ struct LoweringVisitor
     }
 
     void addStmt(
-        StatementSyntaxNode* stmt)
+        Stmt* stmt)
     {
         addStmtImpl(stmtBeingBuilt, stmt);
     }
 
     void addSimpleExprStmt(
-        RefPtr<ExpressionSyntaxNode>    expr)
+        RefPtr<Expr>    expr)
     {
         if (auto infixExpr = expr.As<InfixExpr>())
         {
-            if (auto varExpr = infixExpr->FunctionExpr.As<VarExpressionSyntaxNode>())
+            if (auto varExpr = infixExpr->FunctionExpr.As<VarExpr>())
             {
                 if (varExpr->name == ",")
                 {
@@ -2049,13 +2049,13 @@ struct LoweringVisitor
                 }
             }
         }
-        else if (auto varExpr = expr.As<VarExpressionSyntaxNode>())
+        else if (auto varExpr = expr.As<VarExpr>())
         {
             // Skip an expression that is just a reference to a single variable
             return;
         }
 
-        RefPtr<ExpressionStatementSyntaxNode> stmt = new ExpressionStatementSyntaxNode();
+        RefPtr<ExpressionStmt> stmt = new ExpressionStmt();
         stmt->Expression = expr;
         addStmt(stmt);
     }
@@ -2110,19 +2110,19 @@ struct LoweringVisitor
         }
     }
 
-    void visitExpressionStatementSyntaxNode(ExpressionStatementSyntaxNode* stmt)
+    void visitExpressionStmt(ExpressionStmt* stmt)
     {
         addExprStmt(lowerExprOrTuple(stmt->Expression));
     }
 
-    void visitVarDeclrStatementSyntaxNode(VarDeclrStatementSyntaxNode* stmt)
+    void visitDeclStmt(DeclStmt* stmt)
     {
         DeclVisitor::dispatch(stmt->decl);
     }
 
     void lowerStmtFields(
-        StatementSyntaxNode* loweredStmt,
-        StatementSyntaxNode* originalStmt)
+        Stmt* loweredStmt,
+        Stmt* originalStmt)
     {
         loweredStmt->Position = originalStmt->Position;
         loweredStmt->modifiers = originalStmt->modifiers;
@@ -2147,16 +2147,16 @@ struct LoweringVisitor
         loweredStmt->parentStmt = translateStmtRef(originalStmt->parentStmt);
     }
 
-    void visitContinueStatementSyntaxNode(ContinueStatementSyntaxNode* stmt)
+    void visitContinueStmt(ContinueStmt* stmt)
     {
-        RefPtr<ContinueStatementSyntaxNode> loweredStmt = new ContinueStatementSyntaxNode();
+        RefPtr<ContinueStmt> loweredStmt = new ContinueStmt();
         lowerChildStmtFields(loweredStmt, stmt);
         addStmt(loweredStmt);
     }
 
-    void visitBreakStatementSyntaxNode(BreakStatementSyntaxNode* stmt)
+    void visitBreakStmt(BreakStmt* stmt)
     {
-        RefPtr<BreakStatementSyntaxNode> loweredStmt = new BreakStatementSyntaxNode();
+        RefPtr<BreakStmt> loweredStmt = new BreakStmt();
         lowerChildStmtFields(loweredStmt, stmt);
         addStmt(loweredStmt);
     }
@@ -2168,16 +2168,16 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    void visitDiscardStatementSyntaxNode(DiscardStatementSyntaxNode* stmt)
+    void visitDiscardStmt(DiscardStmt* stmt)
     {
-        RefPtr<DiscardStatementSyntaxNode> loweredStmt = new DiscardStatementSyntaxNode();
+        RefPtr<DiscardStmt> loweredStmt = new DiscardStmt();
         lowerStmtFields(loweredStmt, stmt);
         addStmt(loweredStmt);
     }
 
-    void visitEmptyStatementSyntaxNode(EmptyStatementSyntaxNode* stmt)
+    void visitEmptyStmt(EmptyStmt* stmt)
     {
-        RefPtr<EmptyStatementSyntaxNode> loweredStmt = new EmptyStatementSyntaxNode();
+        RefPtr<EmptyStmt> loweredStmt = new EmptyStmt();
         lowerStmtFields(loweredStmt, stmt);
         addStmt(loweredStmt);
     }
@@ -2189,7 +2189,7 @@ struct LoweringVisitor
 
         for (auto token : stmt->tokens)
         {
-            if (token.Type == TokenType::Identifier)
+            if (token.type == TokenType::Identifier)
                 doSampleRateInputCheck(token.Content);
         }
 
@@ -2208,9 +2208,9 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    void visitIfStatementSyntaxNode(IfStatementSyntaxNode* stmt)
+    void visitIfStmt(IfStmt* stmt)
     {
-        RefPtr<IfStatementSyntaxNode> loweredStmt = new IfStatementSyntaxNode();
+        RefPtr<IfStmt> loweredStmt = new IfStmt();
         lowerStmtFields(loweredStmt, stmt);
 
         loweredStmt->Predicate = lowerExpr(stmt->Predicate);
@@ -2234,8 +2234,8 @@ struct LoweringVisitor
     }
 
     void lowerForStmtCommon(
-        RefPtr<ForStatementSyntaxNode>  loweredStmt,
-        ForStatementSyntaxNode*         stmt)
+        RefPtr<ForStmt>  loweredStmt,
+        ForStmt*         stmt)
     {
         lowerScopeStmtFields(loweredStmt, stmt);
 
@@ -2249,9 +2249,9 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    void visitForStatementSyntaxNode(ForStatementSyntaxNode* stmt)
+    void visitForStmt(ForStmt* stmt)
     {
-        lowerForStmtCommon(new ForStatementSyntaxNode(), stmt);
+        lowerForStmtCommon(new ForStmt(), stmt);
     }
 
     void visitUnscopedForStmt(UnscopedForStmt* stmt)
@@ -2274,18 +2274,18 @@ struct LoweringVisitor
 
         auto varDecl = stmt->varDecl;
 
-        auto varType = lowerType(varDecl->Type);
+        auto varType = lowerType(varDecl->type);
 
         for (IntegerLiteralValue ii = rangeBeginVal; ii < rangeEndVal; ++ii)
         {
-            RefPtr<ConstantExpressionSyntaxNode> constExpr = new ConstantExpressionSyntaxNode();
-            constExpr->Type.type = varType.type;
-            constExpr->ConstType = ConstantExpressionSyntaxNode::ConstantType::Int;
+            RefPtr<ConstantExpr> constExpr = new ConstantExpr();
+            constExpr->type.type = varType.type;
+            constExpr->ConstType = ConstantExpr::ConstantType::Int;
             constExpr->integerValue = ii;
 
             RefPtr<VaryingTupleVarDecl> loweredVarDecl = new VaryingTupleVarDecl();
             loweredVarDecl->Position = varDecl->Position;
-            loweredVarDecl->Type = varType;
+            loweredVarDecl->type = varType;
             loweredVarDecl->expr = LoweredExpr(constExpr);
 
             shared->loweredDecls[varDecl] = LoweredDecl(loweredVarDecl);
@@ -2294,9 +2294,9 @@ struct LoweringVisitor
         }
     }
 
-    void visitWhileStatementSyntaxNode(WhileStatementSyntaxNode* stmt)
+    void visitWhileStmt(WhileStmt* stmt)
     {
-        RefPtr<WhileStatementSyntaxNode> loweredStmt = new WhileStatementSyntaxNode();
+        RefPtr<WhileStmt> loweredStmt = new WhileStmt();
         lowerScopeStmtFields(loweredStmt, stmt);
 
         LoweringVisitor subVisitor = pushScope(loweredStmt, stmt);
@@ -2307,9 +2307,9 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    void visitDoWhileStatementSyntaxNode(DoWhileStatementSyntaxNode* stmt)
+    void visitDoWhileStmt(DoWhileStmt* stmt)
     {
-        RefPtr<DoWhileStatementSyntaxNode> loweredStmt = new DoWhileStatementSyntaxNode();
+        RefPtr<DoWhileStmt> loweredStmt = new DoWhileStmt();
         lowerScopeStmtFields(loweredStmt, stmt);
 
         LoweringVisitor subVisitor = pushScope(loweredStmt, stmt);
@@ -2320,12 +2320,12 @@ struct LoweringVisitor
         addStmt(loweredStmt);
     }
 
-    RefPtr<StatementSyntaxNode> transformSyntaxField(StatementSyntaxNode* stmt)
+    RefPtr<Stmt> transformSyntaxField(Stmt* stmt)
     {
         return lowerStmt(stmt);
     }
 
-    void lowerStmtCommon(StatementSyntaxNode* loweredStmt, StatementSyntaxNode* stmt)
+    void lowerStmtCommon(Stmt* loweredStmt, Stmt* stmt)
     {
         loweredStmt->modifiers = stmt->modifiers;
     }
@@ -2349,13 +2349,13 @@ struct LoweringVisitor
         assign(expr, LoweredExpr(createVarRef(getPosition(expr), varDecl)));
     }
 
-    RefPtr<ExpressionSyntaxNode> createCastExpr(
-        RefPtr<ExpressionType>          type,
-        RefPtr<ExpressionSyntaxNode>    expr)
+    RefPtr<Expr> createCastExpr(
+        RefPtr<Type>          type,
+        RefPtr<Expr>    expr)
     {
         RefPtr<ExplicitCastExpr> castExpr = new ExplicitCastExpr();
         castExpr->Position = expr->Position;
-        castExpr->Type.type = type;
+        castExpr->type.type = type;
         castExpr->TargetType.type = type;
         castExpr->Expression = expr;
         return castExpr;
@@ -2381,9 +2381,9 @@ struct LoweringVisitor
         assignWithFixups(expr, LoweredExpr(createVarRef(getPosition(expr), varDecl)));
     }
 
-    void visitReturnStatementSyntaxNode(ReturnStatementSyntaxNode* stmt)
+    void visitReturnStmt(ReturnStmt* stmt)
     {
-        auto loweredStmt = new ReturnStatementSyntaxNode();
+        auto loweredStmt = new ReturnStmt();
         lowerStmtCommon(loweredStmt, stmt);
 
         if (stmt->Expression)
@@ -2409,7 +2409,7 @@ struct LoweringVisitor
 
     RefPtr<Val> translateVal(Val* val)
     {
-        if (auto type = dynamic_cast<ExpressionType*>(val))
+        if (auto type = dynamic_cast<Type*>(val))
             return lowerType(type);
 
         if (auto litVal = dynamic_cast<ConstantIntVal*>(val))
@@ -2520,7 +2520,7 @@ struct LoweringVisitor
 
         if (isBuildingStmt)
         {
-            RefPtr<VarDeclrStatementSyntaxNode> declStmt = new VarDeclrStatementSyntaxNode();
+            RefPtr<DeclStmt> declStmt = new DeclStmt();
             declStmt->Position = decl->Position;
             declStmt->decl = decl;
             addStmt(declStmt);
@@ -2659,7 +2659,7 @@ struct LoweringVisitor
         SLANG_UNEXPECTED("generics should be lowered to specialized decls");
     }
 
-    LoweredDecl visitProgramSyntaxNode(ProgramSyntaxNode*)
+    LoweredDecl visitModuleDecl(ModuleDecl*)
     {
         SLANG_UNEXPECTED("module decls should be lowered explicitly");
     }
@@ -2696,7 +2696,7 @@ struct LoweringVisitor
         RefPtr<TypeDefDecl> loweredDecl = new TypeDefDecl();
         lowerDeclCommon(loweredDecl, decl);
 
-        loweredDecl->Type = lowerType(decl->Type);
+        loweredDecl->type = lowerType(decl->type);
 
         addMember(shared->loweredProgram, loweredDecl);
         return LoweredDecl(loweredDecl);
@@ -2741,7 +2741,7 @@ struct LoweringVisitor
         return LoweredDecl(loweredDecl);
     }
 
-    TupleTypeModifier* isTupleType(ExpressionType* type)
+    TupleTypeModifier* isTupleType(Type* type)
     {
         if (auto declRefType = type->As<DeclRefType>())
         {
@@ -2754,7 +2754,7 @@ struct LoweringVisitor
         return nullptr;
     }
 
-    ExpressionType* unwrapArray(ExpressionType* inType)
+    Type* unwrapArray(Type* inType)
     {
         auto type = inType;
         while (auto arrayType = type->As<ArrayExpressionType>())
@@ -2764,12 +2764,12 @@ struct LoweringVisitor
         return type;
     }
 
-    TupleTypeModifier* isTupleTypeOrArrayOfTupleType(ExpressionType* type)
+    TupleTypeModifier* isTupleTypeOrArrayOfTupleType(Type* type)
     {
         return isTupleType(unwrapArray(type));
     }
 
-    bool isResourceType(ExpressionType* type)
+    bool isResourceType(Type* type)
     {
         while (auto arrayType = type->As<ArrayExpressionType>())
         {
@@ -2790,7 +2790,7 @@ struct LoweringVisitor
         return false;
     }
 
-    RefPtr<Decl> visitAggTypeDecl(AggTypeDecl* decl)
+    LoweredDecl visitAggTypeDecl(AggTypeDecl* decl)
     {
         // We want to lower any aggregate type declaration
         // to just a `struct` type that contains its fields.
@@ -2798,7 +2798,7 @@ struct LoweringVisitor
         // Any non-field members (e.g., methods) will be
         // lowered separately.
 
-        RefPtr<StructSyntaxNode> loweredDecl = new StructSyntaxNode();
+        RefPtr<StructDecl> loweredDecl = new StructDecl();
         lowerDeclCommon(loweredDecl, decl);
 
         // We need to be ready to turn this type into a "tuple" type,
@@ -2842,7 +2842,7 @@ struct LoweringVisitor
 
             // If the field is of a type that requires special handling,
             // we need to make a note of it.
-            auto loweredFieldType = loweredField->Type.type;
+            auto loweredFieldType = loweredField->type.type;
             bool isTupleField = false;
             bool fieldHasAnyNonTupleFields = false;
             bool fieldHasTupleType = false;
@@ -2911,7 +2911,7 @@ struct LoweringVisitor
         }
 
 
-        return loweredDecl;
+        return LoweredDecl(loweredDecl);
     }
 
     RefPtr<VarDeclBase> lowerSimpleVarDeclCommon(
@@ -2921,8 +2921,8 @@ struct LoweringVisitor
     {
         lowerDeclCommon(loweredDecl, decl);
 
-        loweredDecl->Type = loweredType;
-        loweredDecl->Expr = lowerExpr(decl->Expr);
+        loweredDecl->type = loweredType;
+        loweredDecl->initExpr = lowerExpr(decl->initExpr);
 
         return loweredDecl;
     }
@@ -2931,7 +2931,7 @@ struct LoweringVisitor
         RefPtr<VarDeclBase> loweredDecl,
         VarDeclBase*        decl)
     {
-        auto loweredType = lowerType(decl->Type);
+        auto loweredType = lowerType(decl->type);
         return lowerSimpleVarDeclCommon(loweredDecl, decl, loweredType);
     }
 
@@ -2953,13 +2953,13 @@ struct LoweringVisitor
         String                      name;
 
         // The parent tuple type (or array thereof) we are scalarizing
-        RefPtr<ExpressionType>  tupleType;
+        RefPtr<Type>  tupleType;
 
         // The actual declaration of the tuple type (which will give us the fields)
         DeclRef<AggTypeDecl>    tupleTypeDecl;
 
         // An initializer expression to use for the tuple members
-        RefPtr<ExpressionSyntaxNode>    initExpr;
+        RefPtr<Expr>    initExpr;
 
         // The original layout given to the top-level variable
         RefPtr<VarLayout>               primaryVarLayout;
@@ -2999,7 +2999,7 @@ struct LoweringVisitor
 
             // TODO: need to extract the initializer for this field
             SLANG_RELEASE_ASSERT(!info.initExpr);
-            RefPtr<ExpressionSyntaxNode> fieldInitExpr;
+            RefPtr<Expr> fieldInitExpr;
 
             String fieldName = info.name + "_" + dd.GetName();
 
@@ -3092,7 +3092,7 @@ struct LoweringVisitor
             {
                 // Otherwise the field has a simple type, and we just need to declare the variable here
 
-                RefPtr<ExpressionType> fieldVarType = fieldType;
+                RefPtr<Type> fieldVarType = fieldType;
                 for (auto aa = info.arraySpecs; aa; aa = aa->next)
                 {
                     RefPtr<ArrayExpressionType> arrayType = Slang::getArrayType(
@@ -3104,7 +3104,7 @@ struct LoweringVisitor
 
                 RefPtr<VarDeclBase> fieldVarDecl = info.varDeclClass.createInstance();
                 fieldVarDecl->Name.Content = fieldName;
-                fieldVarDecl->Type.type = fieldVarType;
+                fieldVarDecl->type.type = fieldVarType;
 
                 addDecl(fieldVarDecl);
 
@@ -3133,10 +3133,10 @@ struct LoweringVisitor
         SyntaxClass<VarDeclBase>        varDeclClass,
         RefPtr<VarDeclBase>             originalVarDecl,
         String const&                   name,
-        RefPtr<ExpressionType>          tupleType,
+        RefPtr<Type>          tupleType,
         DeclRef<AggTypeDecl>            tupleTypeDecl,
         TupleTypeModifier*              tupleTypeMod,
-        RefPtr<ExpressionSyntaxNode>    initExpr,
+        RefPtr<Expr>    initExpr,
         RefPtr<VarLayout>               primaryVarLayout,
         RefPtr<StructTypeLayout>        tupleTypeLayout)
     {
@@ -3153,7 +3153,7 @@ struct LoweringVisitor
         {
             RefPtr<VarDeclBase> primaryVarDecl = varDeclClass.createInstance();
             primaryVarDecl->Name.Content = name;
-            primaryVarDecl->Type.type = tupleType;
+            primaryVarDecl->type.type = tupleType;
 
             primaryVarDecl->modifiers = originalVarDecl->modifiers;
 
@@ -3211,9 +3211,9 @@ struct LoweringVisitor
         SyntaxClass<VarDeclBase>        varDeclClass,
         RefPtr<VarDeclBase>             originalVarDecl,
         String const&                   name,
-        RefPtr<ExpressionType>          tupleType,
+        RefPtr<Type>          tupleType,
         TupleTypeModifier*              tupleTypeMod,
-        RefPtr<ExpressionSyntaxNode>    initExpr,
+        RefPtr<Expr>    initExpr,
         RefPtr<VarLayout>               primaryVarLayout)
     {
         RefPtr<StructTypeLayout> tupleTypeLayout;
@@ -3239,7 +3239,7 @@ struct LoweringVisitor
         VarDeclBase*                decl,
         SyntaxClass<VarDeclBase>    loweredDeclClass)
     {
-        auto loweredType = lowerType(decl->Type);
+        auto loweredType = lowerType(decl->type);
 
         if (auto tupleTypeMod = isTupleTypeOrArrayOfTupleType(loweredType))
         {
@@ -3251,7 +3251,7 @@ struct LoweringVisitor
 
             // If the variable had an initializer, we expect it
             // to resolve to a tuple *value*
-            auto loweredInit = lowerExpr(decl->Expr);
+            auto loweredInit = lowerExpr(decl->initExpr);
 
             // TODO: need to extract layout here and propagate it down!
 
@@ -3311,7 +3311,7 @@ struct LoweringVisitor
         // If this is a global variable (program scope), then add it
         // to the global scope.
         RefPtr<ContainerDecl> pp = decl->ParentDecl;
-        if (auto parentModuleDecl = pp.As<ProgramSyntaxNode>())
+        if (auto parentModuleDecl = pp.As<ModuleDecl>())
         {
             LoweringVisitor subVisitor = *this;
             subVisitor.parentDecl = translateDeclRef(parentModuleDecl);
@@ -3328,7 +3328,7 @@ struct LoweringVisitor
         }
     }
 
-    SourceLanguage getSourceLanguage(ProgramSyntaxNode* moduleDecl)
+    SourceLanguage getSourceLanguage(ModuleDecl* moduleDecl)
     {
         for (auto translationUnit : shared->compileRequest->translationUnits)
         {
@@ -3366,7 +3366,7 @@ struct LoweringVisitor
         }
     }
 
-    AggTypeDecl* isStructType(RefPtr<ExpressionType> type)
+    AggTypeDecl* isStructType(RefPtr<Type> type)
     {
         if (type->As<BasicExpressionType>()) return nullptr;
         else if (type->As<VectorExpressionType>()) return nullptr;
@@ -3384,7 +3384,7 @@ struct LoweringVisitor
         return nullptr;
     }
 
-    bool isImportedStructType(RefPtr<ExpressionType> type)
+    bool isImportedStructType(RefPtr<Type> type)
     {
         // TODO: make this use `isStructType` above
 
@@ -3416,7 +3416,7 @@ struct LoweringVisitor
         Variable* decl)
     {
         // Global variable? Check if it is a sample-rate input.
-        if (dynamic_cast<ProgramSyntaxNode*>(decl->ParentDecl))
+        if (dynamic_cast<ModuleDecl*>(decl->ParentDecl))
         {
             if (decl->HasModifier<InModifier>())
             {
@@ -3429,7 +3429,7 @@ struct LoweringVisitor
                 auto inRes = varLayout->FindResourceInfo(LayoutResourceKind::VertexInput);
                 auto outRes = varLayout->FindResourceInfo(LayoutResourceKind::FragmentOutput);
 
-                if( (inRes || outRes) && isImportedStructType(decl->Type.type))
+                if( (inRes || outRes) && isImportedStructType(decl->type.type))
                 {
                     // We are seemingly looking at a GLSL global-scope varying
                     // of an aggregate type which was imported from library
@@ -3480,10 +3480,10 @@ struct LoweringVisitor
         return LoweredDecl(lowerSimpleVarDeclCommon(new StructField(), decl));
     }
 
-    LoweredDecl visitParameterSyntaxNode(
-        ParameterSyntaxNode* decl)
+    LoweredDecl visitParamDecl(
+        ParamDecl* decl)
     {
-        auto loweredDecl = lowerVarDeclCommon(decl, getClass<ParameterSyntaxNode>());
+        auto loweredDecl = lowerVarDeclCommon(decl, getClass<ParamDecl>());
         return loweredDecl;
     }
 
@@ -3508,7 +3508,7 @@ struct LoweringVisitor
     {
         // TODO: need to generate a name
 
-        RefPtr<FunctionSyntaxNode> loweredDecl = new FunctionSyntaxNode();
+        RefPtr<FuncDecl> loweredDecl = new FuncDecl();
         lowerDeclCommon(loweredDecl, decl);
 
         // TODO: push scope for parent decl here...
@@ -3612,18 +3612,18 @@ struct LoweringVisitor
         VaryingParameterVarChain*   varChain = nullptr;
     };
 
-    RefPtr<ExpressionSyntaxNode> createGLSLBuiltinRef(
+    RefPtr<Expr> createGLSLBuiltinRef(
         char const*             name,
-        RefPtr<ExpressionType>  type)
+        RefPtr<Type>  type)
     {
-        RefPtr<VarExpressionSyntaxNode> globalVarRef = new VarExpressionSyntaxNode();
+        RefPtr<VarExpr> globalVarRef = new VarExpr();
         globalVarRef->name = name;
-        globalVarRef->Type.type = type;
+        globalVarRef->type.type = type;
         return globalVarRef;
     }
 
     bool isIntegralType(
-        ExpressionType* type)
+        Type* type)
     {
         if (auto baseType = type->As<BasicExpressionType>())
         {
@@ -3659,28 +3659,28 @@ struct LoweringVisitor
         Slang::requireGLSLVersion(entryPoint, version);
     }
 
-    RefPtr<ExpressionType> getFloatType()
+    RefPtr<Type> getFloatType()
     {
         return getSession()->getFloatType();
     }
 
-    RefPtr<ExpressionType> getIntType()
+    RefPtr<Type> getIntType()
     {
         return getSession()->getIntType();
     }
 
-    RefPtr<ExpressionType> getUIntType()
+    RefPtr<Type> getUIntType()
     {
         return getSession()->getUIntType();
     }
 
-    RefPtr<ExpressionType> getBoolType()
+    RefPtr<Type> getBoolType()
     {
         return getSession()->getBoolType();
     }
 
     RefPtr<VectorExpressionType> getVectorType(
-        RefPtr<ExpressionType>  elementType,
+        RefPtr<Type>  elementType,
         RefPtr<IntVal>          elementCount)
     {
         auto session = getSession();
@@ -3709,21 +3709,21 @@ struct LoweringVisitor
     }
 
     RefPtr<VectorExpressionType> getVectorType(
-        RefPtr<ExpressionType>  elementType,
+        RefPtr<Type>  elementType,
         int                     elementCount)
     {
         return getVectorType(elementType, getConstantIntVal(elementCount));
     }
 
     RefPtr<ArrayExpressionType> getUnsizedArrayType(
-        RefPtr<ExpressionType>  elementType)
+        RefPtr<Type>  elementType)
     {
         RefPtr<ArrayExpressionType> arrayType = Slang::getArrayType(elementType);
         return arrayType;
     }
 
     RefPtr<ArrayExpressionType> getArrayType(
-        RefPtr<ExpressionType>  elementType,
+        RefPtr<Type>  elementType,
         IntegerLiteralValue     elementCount)
     {
         return Slang::getArrayType(elementType, getConstantIntVal(elementCount));
@@ -3731,10 +3731,10 @@ struct LoweringVisitor
 
     LoweredExpr lowerSimpleShaderParameterToGLSLGlobal(
         VaryingParameterInfo const&     info,
-        RefPtr<ExpressionType>          varType,
+        RefPtr<Type>          varType,
         RefPtr<VarLayout>               varLayout)
     {
-        RefPtr<ExpressionType> type = varType;
+        RefPtr<Type> type = varType;
 
         for (auto aa = info.arraySpecs; aa; aa = aa->next)
         {
@@ -3750,7 +3750,7 @@ struct LoweringVisitor
         // We need to create a reference to the global-scope declaration
         // of the proper GLSL input/output variable. This might
         // be a user-defined input/output, or a system-defined `gl_` one.
-        RefPtr<ExpressionSyntaxNode> globalVarExpr;
+        RefPtr<Expr> globalVarExpr;
 
         // Handle system-value inputs/outputs
         SLANG_RELEASE_ASSERT(varLayout);
@@ -3941,7 +3941,7 @@ struct LoweringVisitor
         {
             RefPtr<Variable> globalVarDecl = new Variable();
             globalVarDecl->Name.Content = info.name;
-            globalVarDecl->Type.type = type;
+            globalVarDecl->type.type = type;
 
             ensureDeclHasAValidName(globalVarDecl);
 
@@ -3998,9 +3998,9 @@ struct LoweringVisitor
             }
 
 
-            RefPtr<VarExpressionSyntaxNode> globalVarRef = new VarExpressionSyntaxNode();
+            RefPtr<VarExpr> globalVarRef = new VarExpr();
             globalVarRef->Position = globalVarDecl->Position;
-            globalVarRef->Type.type = globalVarDecl->Type.type;
+            globalVarRef->type.type = globalVarDecl->type.type;
             globalVarRef->declRef = makeDeclRef(globalVarDecl.Ptr());
             globalVarRef->name = globalVarDecl->getName();
 
@@ -4012,7 +4012,7 @@ struct LoweringVisitor
 
     LoweredExpr lowerShaderParameterToGLSLGLobalsRec(
         VaryingParameterInfo const&     info,
-        RefPtr<ExpressionType>          varType,
+        RefPtr<Type>          varType,
         RefPtr<VarLayout>               varLayout)
     {
         SLANG_RELEASE_ASSERT(varLayout);
@@ -4063,9 +4063,9 @@ struct LoweringVisitor
                 // to destructure it into its constituent fields
 
                 RefPtr<VaryingTupleExpr> tupleExpr = new VaryingTupleExpr();
-                tupleExpr->Type.type = varType;
+                tupleExpr->type.type = varType;
 
-                SLANG_RELEASE_ASSERT(tupleExpr->Type.type);
+                SLANG_RELEASE_ASSERT(tupleExpr->type.type);
 
                 for (auto fieldDeclRef : getMembersOfType<VarDeclBase>(aggTypeDeclRef))
                 {
@@ -4143,7 +4143,7 @@ struct LoweringVisitor
             break;
         }
 
-        auto loweredType = lowerType(originalVarDecl->Type);
+        auto loweredType = lowerType(originalVarDecl->type);
 
         auto loweredExpr = lowerShaderParameterToGLSLGLobalsRec(
             info,
@@ -4170,7 +4170,7 @@ struct LoweringVisitor
     {
         RefPtr<VaryingTupleVarDecl> loweredDecl = new VaryingTupleVarDecl();
         loweredDecl->Name = originalVarDecl->Name;
-        loweredDecl->Type = loweredType;
+        loweredDecl->type = loweredType;
         loweredDecl->expr = loweredExpr;
 
         return loweredDecl;
@@ -4180,26 +4180,26 @@ struct LoweringVisitor
         RefPtr<VarDeclBase>     originalVarDecl,
         LoweredExpr             loweredExpr)
     {
-        auto loweredType = lowerType(originalVarDecl->Type);
+        auto loweredType = lowerType(originalVarDecl->type);
         return createVaryingTupleVarDecl(originalVarDecl, loweredType, loweredExpr);
     }
 
     struct EntryPointParamPair
     {
-        RefPtr<ParameterSyntaxNode> original;
+        RefPtr<ParamDecl> original;
         RefPtr<VarLayout>           layout;
         RefPtr<Variable>            lowered;
     };
 
-    RefPtr<FunctionSyntaxNode> lowerEntryPointToGLSL(
-        FunctionSyntaxNode*         entryPointDecl,
+    RefPtr<FuncDecl> lowerEntryPointToGLSL(
+        FuncDecl*         entryPointDecl,
         RefPtr<EntryPointLayout>    entryPointLayout)
     {
         // First, loer the entry-point function as an ordinary function:
         auto loweredEntryPointFunc = visitFunctionDeclBase(entryPointDecl).getDecl()->As<FunctionDeclBase>();
 
         // Now we will generate a `void main() { ... }` function to call the lowered code.
-        RefPtr<FunctionSyntaxNode> mainDecl = new FunctionSyntaxNode();
+        RefPtr<FuncDecl> mainDecl = new FuncDecl();
         mainDecl->ReturnType.type = getSession()->getVoidType();
         mainDecl->Name.Content = "main";
 
@@ -4232,7 +4232,7 @@ struct LoweringVisitor
             RefPtr<Variable> localVarDecl = new Variable();
             localVarDecl->Position = paramDecl->Position;
             localVarDecl->Name.Content = paramDecl->getName();
-            localVarDecl->Type = lowerType(paramDecl->Type);
+            localVarDecl->type = lowerType(paramDecl->type);
 
             ensureDeclHasAValidName(localVarDecl);
 
@@ -4270,7 +4270,7 @@ struct LoweringVisitor
             resultVarDecl = new Variable();
             resultVarDecl->Position = loweredEntryPointFunc->Position;
             resultVarDecl->Name.Content = "main_result";
-            resultVarDecl->Type = TypeExp(loweredEntryPointFunc->ReturnType);
+            resultVarDecl->type = TypeExp(loweredEntryPointFunc->ReturnType);
 
             ensureDeclHasAValidName(resultVarDecl);
 
@@ -4284,24 +4284,24 @@ struct LoweringVisitor
             getSession(),
             entryPointDeclRef);
 
-        RefPtr<VarExpressionSyntaxNode> entryPointRef = new VarExpressionSyntaxNode();
+        RefPtr<VarExpr> entryPointRef = new VarExpr();
         entryPointRef->name = loweredEntryPointFunc->getName();
         entryPointRef->declRef = entryPointDeclRef;
-        entryPointRef->Type = QualType(entryPointType);
+        entryPointRef->type = QualType(entryPointType);
 
-        RefPtr<InvokeExpressionSyntaxNode> callExpr = new InvokeExpressionSyntaxNode();
+        RefPtr<InvokeExpr> callExpr = new InvokeExpr();
         callExpr->FunctionExpr = entryPointRef;
-        callExpr->Type = QualType(loweredEntryPointFunc->ReturnType);
+        callExpr->type = QualType(loweredEntryPointFunc->ReturnType);
 
         //
         for (auto paramPair : params)
         {
             auto localVarDecl = paramPair.lowered;
 
-            RefPtr<VarExpressionSyntaxNode> varRef = new VarExpressionSyntaxNode();
+            RefPtr<VarExpr> varRef = new VarExpr();
             varRef->name = localVarDecl->getName();
             varRef->declRef = makeDeclRef(localVarDecl.Ptr());
-            varRef->Type = QualType(localVarDecl->getType());
+            varRef->type = QualType(localVarDecl->getType());
 
             callExpr->Arguments.Add(varRef);
         }
@@ -4342,7 +4342,7 @@ struct LoweringVisitor
 
             auto loweredExpr = lowerShaderParameterToGLSLGLobalsRec(
                 info,
-                resultVarDecl->Type.type,
+                resultVarDecl->type.type,
                 entryPointLayout->resultLayout);
 
             subVisitor.assignWithFixups(loweredExpr, resultVarDecl);
@@ -4364,7 +4364,7 @@ struct LoweringVisitor
         return mainDecl;
 
 #if 0
-        RefPtr<FunctionSyntaxNode> loweredDecl = new FunctionSyntaxNode();
+        RefPtr<FuncDecl> loweredDecl = new FuncDecl();
         lowerDeclCommon(loweredDecl, entryPointDecl);
 
         // We create a sub-context appropriate for lowering the function body
@@ -4389,7 +4389,7 @@ struct LoweringVisitor
             resultGlobal = new Variable();
             // TODO: need a scheme for generating unique names
             resultGlobal->Name.Content = "_main_result";
-            resultGlobal->Type = loweredReturnType;
+            resultGlobal->type = loweredReturnType;
 
             addMember(shared->loweredProgram, resultGlobal);
         }
@@ -4414,15 +4414,15 @@ struct LoweringVisitor
 #endif
     }
 
-    RefPtr<FunctionSyntaxNode> lowerEntryPoint(
-        FunctionSyntaxNode*         entryPointDecl,
+    RefPtr<FuncDecl> lowerEntryPoint(
+        FuncDecl*         entryPointDecl,
         RefPtr<EntryPointLayout>    entryPointLayout)
     {
         switch( getTarget() )
         {
         // Default case: lower an entry point just like any other function
         default:
-            return visitFunctionDeclBase(entryPointDecl).getDecl()->As<FunctionSyntaxNode>();
+            return visitFunctionDeclBase(entryPointDecl).getDecl()->As<FuncDecl>();
 
         // For Slang->GLSL translation, we need to lower things from HLSL-style
         // declarations over to GLSL conventions
@@ -4431,7 +4431,7 @@ struct LoweringVisitor
         }
     }
 
-    RefPtr<FunctionSyntaxNode> lowerEntryPoint(
+    RefPtr<FuncDecl> lowerEntryPoint(
         EntryPointRequest*  entryPointRequest)
     {
         auto entryPointLayout = findEntryPointLayout(entryPointRequest);
@@ -4533,7 +4533,7 @@ LoweredEntryPoint lowerEntryPoint(
     // Create a single module/program to hold all the lowered code
     // (with the exception of instrinsic/stdlib declarations, which
     // will be remain where they are)
-    RefPtr<ProgramSyntaxNode> loweredProgram = new ProgramSyntaxNode();
+    RefPtr<ModuleDecl> loweredProgram = new ModuleDecl();
     sharedContext.loweredProgram = loweredProgram;
 
     LoweringVisitor visitor;
diff --git a/source/slang/lower.h b/source/slang/lower.h
index 688c1df8f..919260af3 100644
--- a/source/slang/lower.h
+++ b/source/slang/lower.h
@@ -22,12 +22,12 @@ namespace Slang
     struct LoweredEntryPoint
     {
         // The actual lowered entry point
-        RefPtr<FunctionSyntaxNode>  entryPoint;
+        RefPtr<FuncDecl>  entryPoint;
 
         // The generated program AST that
         // contains the entry point and any
         // other declarations it uses
-        RefPtr<ProgramSyntaxNode>   program;
+        RefPtr<ModuleDecl>   program;
     };
 
     // Emit code for a single entry point, based on
diff --git a/source/slang/modifier-defs.h b/source/slang/modifier-defs.h
index 89f2096e4..5bab29aba 100644
--- a/source/slang/modifier-defs.h
+++ b/source/slang/modifier-defs.h
@@ -265,7 +265,7 @@ SIMPLE_SYNTAX_CLASS(HLSLVolatileModifier, Modifier)
 // An HLSL `[name(arg0, ...)]` style attribute.
 SYNTAX_CLASS(HLSLAttribute, Modifier)
     FIELD(Token, nameToken)
-    SYNTAX_FIELD(List<RefPtr<ExpressionSyntaxNode>>, args)
+    SYNTAX_FIELD(List<RefPtr<Expr>>, args)
 END_SYNTAX_CLASS()
 
 // An HLSL `[name(...)]` attribute that hasn't undergone
diff --git a/source/slang/parameter-binding.cpp b/source/slang/parameter-binding.cpp
index 9b1036d02..eeaa04a3f 100644
--- a/source/slang/parameter-binding.cpp
+++ b/source/slang/parameter-binding.cpp
@@ -390,7 +390,7 @@ static bool isGLSLBuiltinName(VarDeclBase* varDecl)
     return getReflectionName(varDecl).StartsWith("gl_");
 }
 
-RefPtr<ExpressionType> tryGetEffectiveTypeForGLSLVaryingInput(
+RefPtr<Type> tryGetEffectiveTypeForGLSLVaryingInput(
     ParameterBindingContext*    context,
     VarDeclBase*                varDecl)
 {
@@ -428,7 +428,7 @@ RefPtr<ExpressionType> tryGetEffectiveTypeForGLSLVaryingInput(
     return nullptr;
 }
 
-RefPtr<ExpressionType> tryGetEffectiveTypeForGLSLVaryingOutput(
+RefPtr<Type> tryGetEffectiveTypeForGLSLVaryingOutput(
     ParameterBindingContext*    context,
     VarDeclBase*                varDecl)
 {
@@ -592,14 +592,14 @@ struct EntryPointParameterState
 
 static RefPtr<TypeLayout> processEntryPointParameter(
     ParameterBindingContext*        context,
-    RefPtr<ExpressionType>          type,
+    RefPtr<Type>          type,
     EntryPointParameterState const& state,
     RefPtr<VarLayout>               varLayout);
 
 static void collectGlobalScopeGLSLVaryingParameter(
     ParameterBindingContext*        context,
     RefPtr<VarDeclBase>             varDecl,
-    RefPtr<ExpressionType>          effectiveType,
+    RefPtr<Type>          effectiveType,
     EntryPointParameterDirection    direction)
 {
     int defaultSemanticIndex = 0;
@@ -994,7 +994,7 @@ static void completeBindingsForParameter(
 
 static void collectGlobalScopeParameters(
     ParameterBindingContext*    context,
-    ProgramSyntaxNode*          program)
+    ModuleDecl*          program)
 {
     // First enumerate parameters at global scope
     for( auto decl : program->Members )
@@ -1066,7 +1066,7 @@ SimpleSemanticInfo decomposeSimpleSemantic(
 
 static RefPtr<TypeLayout> processSimpleEntryPointParameter(
     ParameterBindingContext*        context,
-    RefPtr<ExpressionType>          type,
+    RefPtr<Type>          type,
     EntryPointParameterState const& inState,
     RefPtr<VarLayout>               varLayout,
     int                             semanticSlotCount = 1)
@@ -1147,7 +1147,7 @@ static RefPtr<TypeLayout> processSimpleEntryPointParameter(
 static RefPtr<TypeLayout> processEntryPointParameterWithPossibleSemantic(
     ParameterBindingContext*        context,
     Decl*                           declForSemantic,
-    RefPtr<ExpressionType>          type,
+    RefPtr<Type>          type,
     EntryPointParameterState const& state,
     RefPtr<VarLayout>               varLayout)
 {
@@ -1178,7 +1178,7 @@ static RefPtr<TypeLayout> processEntryPointParameterWithPossibleSemantic(
 
 static RefPtr<TypeLayout> processEntryPointParameter(
     ParameterBindingContext*        context,
-    RefPtr<ExpressionType>          type,
+    RefPtr<Type>          type,
     EntryPointParameterState const& state,
     RefPtr<VarLayout>               varLayout)
 {
@@ -1235,7 +1235,7 @@ static RefPtr<TypeLayout> processEntryPointParameter(
     {
         auto declRef = declRefType->declRef;
 
-        if (auto structDeclRef = declRef.As<StructSyntaxNode>())
+        if (auto structDeclRef = declRef.As<StructDecl>())
         {
             RefPtr<StructTypeLayout> structLayout = new StructTypeLayout();
             structLayout->type = type;
@@ -1288,7 +1288,7 @@ static RefPtr<TypeLayout> processEntryPointParameter(
 static void collectEntryPointParameters(
     ParameterBindingContext*        context,
     EntryPointRequest*              entryPoint,
-    ProgramSyntaxNode*              translationUnitSyntax)
+    ModuleDecl*              translationUnitSyntax)
 {
     // First, look for the entry point with the specified name
 
@@ -1307,7 +1307,7 @@ static void collectEntryPointParameters(
         return;
     }
 
-    FunctionSyntaxNode* entryPointFuncDecl = dynamic_cast<FunctionSyntaxNode*>(entryPointDecl);
+    FuncDecl* entryPointFuncDecl = dynamic_cast<FuncDecl*>(entryPointDecl);
     if( !entryPointFuncDecl )
     {
         // Not a function!
@@ -1368,7 +1368,7 @@ static void collectEntryPointParameters(
         auto paramTypeLayout = processEntryPointParameterWithPossibleSemantic(
             context,
             paramDecl.Ptr(),
-            paramDecl->Type.type,
+            paramDecl->type.type,
             state,
             paramVarLayout);
 
@@ -1443,7 +1443,7 @@ inferStageForTranslationUnit(
 
 static void collectModuleParameters(
     ParameterBindingContext*    inContext,
-    ProgramSyntaxNode*          module)
+    ModuleDecl*          module)
 {
     // Each loaded module provides a separate (logical) namespace for
     // parameters, so that two parameters with the same name, in
@@ -1689,10 +1689,10 @@ void generateParameterBindings(
 
         RefPtr<Variable> var = new Variable();
         var->Name.Content = "SLANG_hack_samplerForTexelFetch";
-        var->Type.type = getSamplerStateType(request->mSession);
+        var->type.type = getSamplerStateType(request->mSession);
 
         auto typeLayout = new TypeLayout();
-        typeLayout->type = var->Type.type;
+        typeLayout->type = var->type.type;
         typeLayout->addResourceUsage(LayoutResourceKind::DescriptorTableSlot, 1);
 
         auto varLayout = new VarLayout();
diff --git a/source/slang/parser.cpp b/source/slang/parser.cpp
index c36b2f477..41a4411d2 100644
--- a/source/slang/parser.cpp
+++ b/source/slang/parser.cpp
@@ -86,37 +86,37 @@ namespace Slang
             return translationUnit->compileRequest->mSession;
         }
 
-        RefPtr<ProgramSyntaxNode> Parse();
+        RefPtr<ModuleDecl> Parse();
 
         Token ReadToken();
         Token ReadToken(TokenType type);
         Token ReadToken(const char * string);
         bool LookAheadToken(TokenType type, int offset = 0);
         bool LookAheadToken(const char * string, int offset = 0);
-        void                                        parseSourceFile(ProgramSyntaxNode* program);
-        RefPtr<ProgramSyntaxNode>					ParseProgram();
-        RefPtr<StructSyntaxNode>					ParseStruct();
-        RefPtr<ClassSyntaxNode>					    ParseClass();
-        RefPtr<StatementSyntaxNode>					ParseStatement();
-        RefPtr<StatementSyntaxNode>			        ParseBlockStatement();
-        RefPtr<VarDeclrStatementSyntaxNode>			ParseVarDeclrStatement(Modifiers modifiers);
-        RefPtr<IfStatementSyntaxNode>				ParseIfStatement();
-        RefPtr<ForStatementSyntaxNode>				ParseForStatement();
-        RefPtr<WhileStatementSyntaxNode>			ParseWhileStatement();
-        RefPtr<DoWhileStatementSyntaxNode>			ParseDoWhileStatement();
-        RefPtr<BreakStatementSyntaxNode>			ParseBreakStatement();
-        RefPtr<ContinueStatementSyntaxNode>			ParseContinueStatement();
-        RefPtr<ReturnStatementSyntaxNode>			ParseReturnStatement();
-        RefPtr<ExpressionStatementSyntaxNode>		ParseExpressionStatement();
-        RefPtr<ExpressionSyntaxNode>				ParseExpression(Precedence level = Precedence::Comma);
+        void                                        parseSourceFile(ModuleDecl* program);
+        RefPtr<ModuleDecl>					ParseProgram();
+        RefPtr<StructDecl>					ParseStruct();
+        RefPtr<ClassDecl>					    ParseClass();
+        RefPtr<Stmt>					ParseStatement();
+        RefPtr<Stmt>			        ParseBlockStatement();
+        RefPtr<DeclStmt>			ParseVarDeclrStatement(Modifiers modifiers);
+        RefPtr<IfStmt>				ParseIfStatement();
+        RefPtr<ForStmt>				ParseForStatement();
+        RefPtr<WhileStmt>			ParseWhileStatement();
+        RefPtr<DoWhileStmt>			ParseDoWhileStatement();
+        RefPtr<BreakStmt>			ParseBreakStatement();
+        RefPtr<ContinueStmt>			ParseContinueStatement();
+        RefPtr<ReturnStmt>			ParseReturnStatement();
+        RefPtr<ExpressionStmt>		ParseExpressionStatement();
+        RefPtr<Expr>				ParseExpression(Precedence level = Precedence::Comma);
 
         // Parse an expression that might be used in an initializer or argument context, so we should avoid operator-comma
-        inline RefPtr<ExpressionSyntaxNode>			ParseInitExpr() { return ParseExpression(Precedence::Assignment); }
-        inline RefPtr<ExpressionSyntaxNode>			ParseArgExpr()  { return ParseExpression(Precedence::Assignment); }
+        inline RefPtr<Expr>			ParseInitExpr() { return ParseExpression(Precedence::Assignment); }
+        inline RefPtr<Expr>			ParseArgExpr()  { return ParseExpression(Precedence::Assignment); }
 
-        RefPtr<ExpressionSyntaxNode>				ParseLeafExpression();
-        RefPtr<ParameterSyntaxNode>					ParseParameter();
-        RefPtr<ExpressionSyntaxNode>				ParseType();
+        RefPtr<Expr>				ParseLeafExpression();
+        RefPtr<ParamDecl>					ParseParameter();
+        RefPtr<Expr>				ParseType();
         TypeExp										ParseTypeExp();
 
         Parser & operator = (const Parser &) = delete;
@@ -204,7 +204,7 @@ namespace Slang
     static TokenType SkipBalancedToken(
         TokenReader* reader)
     {
-        TokenType tokenType = reader->AdvanceToken().Type;
+        TokenType tokenType = reader->AdvanceToken().type;
         switch (tokenType)
         {
         default:
@@ -526,7 +526,7 @@ namespace Slang
         return false;
     }
 
-    RefPtr<ProgramSyntaxNode> Parser::Parse()
+    RefPtr<ModuleDecl> Parser::Parse()
     {
         return ParseProgram();
     }
@@ -545,7 +545,7 @@ namespace Slang
         auto nameToken = parser->ReadToken(TokenType::Identifier);
 
         typeDefDecl->Name = nameToken;
-        typeDefDecl->Type = type;
+        typeDefDecl->type = type;
 
         return typeDefDecl;
     }
@@ -937,7 +937,7 @@ namespace Slang
         if (AdvanceIf(parser, "operator"))
         {
             name = parser->ReadToken();
-            switch (name.Type)
+            switch (name.type)
             {
             case TokenType::OpAdd: case TokenType::OpSub: case TokenType::OpMul: case TokenType::OpDiv:
             case TokenType::OpMod: case TokenType::OpNot: case TokenType::OpBitNot: case TokenType::OpLsh: case TokenType::OpRsh:
@@ -1017,16 +1017,16 @@ namespace Slang
         CodePosition openBracketLoc;
 
         // The expression that yields the element count, or NULL
-        RefPtr<ExpressionSyntaxNode>	elementCountExpr;
+        RefPtr<Expr>	elementCountExpr;
     };
 
     // "Unwrapped" information about a declarator
     struct DeclaratorInfo
     {
-        RefPtr<ExpressionSyntaxNode>	typeSpec;
+        RefPtr<Expr>	typeSpec;
         Token							nameToken;
         RefPtr<Modifier>				semantics;
-        RefPtr<ExpressionSyntaxNode>	initializer;
+        RefPtr<Expr>	initializer;
     };
 
     // Add a member declaration to its container, and ensure that its
@@ -1081,7 +1081,7 @@ namespace Slang
     static void ParseFuncDeclHeader(
         Parser*                     parser,
         DeclaratorInfo const&       declaratorInfo,
-        RefPtr<FunctionSyntaxNode>  decl)
+        RefPtr<FuncDecl>  decl)
     {
         parser->PushScope(decl.Ptr());
 
@@ -1099,7 +1099,7 @@ namespace Slang
         ContainerDecl*          /*containerDecl*/,
         DeclaratorInfo const&   declaratorInfo)
     {
-        RefPtr<FunctionSyntaxNode> decl = new FunctionSyntaxNode();
+        RefPtr<FuncDecl> decl = new FuncDecl();
         ParseFuncDeclHeader(parser, declaratorInfo, decl);
 
         if (AdvanceIf(parser, TokenType::Semicolon))
@@ -1118,13 +1118,13 @@ namespace Slang
     static RefPtr<VarDeclBase> CreateVarDeclForContext(
         ContainerDecl*  containerDecl )
     {
-        if (dynamic_cast<StructSyntaxNode*>(containerDecl) || dynamic_cast<ClassSyntaxNode*>(containerDecl))
+        if (dynamic_cast<StructDecl*>(containerDecl) || dynamic_cast<ClassDecl*>(containerDecl))
         {
             return new StructField();
         }
         else if (dynamic_cast<CallableDecl*>(containerDecl))
         {
-            return new ParameterSyntaxNode();
+            return new ParamDecl();
         }
         else
         {
@@ -1167,7 +1167,7 @@ namespace Slang
     {
         parser->FillPosition(decl.Ptr());
 
-        if( declaratorInfo.nameToken.Type == TokenType::Unknown )
+        if( declaratorInfo.nameToken.type == TokenType::Unknown )
         {
             // HACK(tfoley): we always give a name, even if the declarator didn't include one... :(
             decl->Name.Content = generateName(parser);
@@ -1177,11 +1177,11 @@ namespace Slang
             decl->Position = declaratorInfo.nameToken.Position;
             decl->Name = declaratorInfo.nameToken;
         }
-        decl->Type = TypeExp(declaratorInfo.typeSpec);
+        decl->type = TypeExp(declaratorInfo.typeSpec);
 
         AddModifiers(decl.Ptr(), declaratorInfo.semantics);
 
-        decl->Expr = declaratorInfo.initializer;
+        decl->initExpr = declaratorInfo.initializer;
     }
 
     static RefPtr<Declarator> ParseDeclarator(Parser* parser);
@@ -1291,7 +1291,7 @@ namespace Slang
     {
         RefPtr<Declarator>				declarator;
         RefPtr<Modifier>				semantics;
-        RefPtr<ExpressionSyntaxNode>	initializer;
+        RefPtr<Expr>	initializer;
     };
 
     // Parse a declarator plus optional semantics
@@ -1348,7 +1348,7 @@ namespace Slang
                     // TODO(tfoley): we don't support pointers for now
                     auto arrayDeclarator = (ArrayDeclarator*) declarator.Ptr();
 
-                    auto arrayTypeExpr = new IndexExpressionSyntaxNode();
+                    auto arrayTypeExpr = new IndexExpr();
                     arrayTypeExpr->Position = arrayDeclarator->openBracketLoc;
                     arrayTypeExpr->BaseExpression = ioInfo->typeSpec;
                     arrayTypeExpr->IndexExpression = arrayDeclarator->elementCountExpr;
@@ -1413,13 +1413,13 @@ namespace Slang
     };
 
     // Pares an argument to an application of a generic
-    RefPtr<ExpressionSyntaxNode> ParseGenericArg(Parser* parser)
+    RefPtr<Expr> ParseGenericArg(Parser* parser)
     {
         return parser->ParseArgExpr();
     }
 
     // Create a type expression that will refer to the given declaration
-    static RefPtr<ExpressionSyntaxNode>
+    static RefPtr<Expr>
     createDeclRefType(Parser* parser, RefPtr<Decl> decl)
     {
         // For now we just construct an expression that
@@ -1427,7 +1427,7 @@ namespace Slang
         //
         // TODO: do this better, e.g. by filling in the `declRef` field directly
 
-        auto expr = new VarExpressionSyntaxNode();
+        auto expr = new VarExpr();
         expr->scope = parser->currentScope.Ptr();
         expr->Position = decl->getNameToken().Position;
         expr->name = decl->getName();
@@ -1442,12 +1442,12 @@ namespace Slang
         RefPtr<Decl>                    decl;
 
         // Put the resulting expression (which should evaluate to a type) here
-        RefPtr<ExpressionSyntaxNode>    expr;
+        RefPtr<Expr>    expr;
     };
 
-    static RefPtr<ExpressionSyntaxNode> parseGenericApp(
+    static RefPtr<Expr> parseGenericApp(
         Parser*                         parser,
-        RefPtr<ExpressionSyntaxNode>    base)
+        RefPtr<Expr>    base)
     {
         RefPtr<GenericAppExpr> genericApp = new GenericAppExpr();
 
@@ -1472,14 +1472,14 @@ namespace Slang
     }
 
     // Parse option `[]` braces after a type expression, that indicate an array type
-    static RefPtr<ExpressionSyntaxNode> parsePostfixTypeSuffix(
+    static RefPtr<Expr> parsePostfixTypeSuffix(
         Parser* parser,
-        RefPtr<ExpressionSyntaxNode> inTypeExpr)
+        RefPtr<Expr> inTypeExpr)
     {
         auto typeExpr = inTypeExpr;
         while (parser->LookAheadToken(TokenType::LBracket))
         {
-            RefPtr<IndexExpressionSyntaxNode> arrType = new IndexExpressionSyntaxNode();
+            RefPtr<IndexExpr> arrType = new IndexExpr();
             arrType->Position = typeExpr->Position;
             arrType->BaseExpression = typeExpr;
             parser->ReadToken(TokenType::LBracket);
@@ -1520,12 +1520,12 @@ namespace Slang
 
         Token typeName = parser->ReadToken(TokenType::Identifier);
 
-        auto basicType = new VarExpressionSyntaxNode();
+        auto basicType = new VarExpr();
         basicType->scope = parser->currentScope.Ptr();
         basicType->Position = typeName.Position;
         basicType->name = typeName.Content;
 
-        RefPtr<ExpressionSyntaxNode> typeExpr = basicType;
+        RefPtr<Expr> typeExpr = basicType;
 
         if (parser->LookAheadToken(TokenType::OpLess))
         {
@@ -1797,7 +1797,7 @@ namespace Slang
         // We are going to represent each buffer as a pair of declarations.
         // The first is a type declaration that holds all the members, while
         // the second is a variable declaration that uses the buffer type.
-        RefPtr<StructSyntaxNode> bufferDataTypeDecl = new StructSyntaxNode();
+        RefPtr<StructDecl> bufferDataTypeDecl = new StructDecl();
         RefPtr<Variable> bufferVarDecl = new Variable();
 
         // Both declarations will have a location that points to the name
@@ -1824,13 +1824,13 @@ namespace Slang
         // these constructs directly into the AST and *then* desugar them.
 
         // Construct a type expression to reference the buffer data type
-        auto bufferDataTypeExpr = new VarExpressionSyntaxNode();
+        auto bufferDataTypeExpr = new VarExpr();
         bufferDataTypeExpr->Position = bufferDataTypeDecl->Position;
         bufferDataTypeExpr->name = bufferDataTypeDecl->Name.Content;
         bufferDataTypeExpr->scope = parser->currentScope.Ptr();
 
         // Construct a type exrpession to reference the type constructor
-        auto bufferWrapperTypeExpr = new VarExpressionSyntaxNode();
+        auto bufferWrapperTypeExpr = new VarExpr();
         bufferWrapperTypeExpr->Position = bufferWrapperTypeNamePos;
         bufferWrapperTypeExpr->name = bufferWrapperTypeName;
 
@@ -1845,7 +1845,7 @@ namespace Slang
         bufferVarTypeExpr->FunctionExpr = bufferWrapperTypeExpr;
         bufferVarTypeExpr->Arguments.Add(bufferDataTypeExpr);
 
-        bufferVarDecl->Type.exp = bufferVarTypeExpr;
+        bufferVarDecl->type.exp = bufferVarTypeExpr;
 
         // Any semantics applied to the bufer declaration are taken as applying
         // to the variable instead.
@@ -1953,7 +1953,7 @@ namespace Slang
         // We are going to represent each buffer as a pair of declarations.
         // The first is a type declaration that holds all the members, while
         // the second is a variable declaration that uses the buffer type.
-        RefPtr<StructSyntaxNode> blockDataTypeDecl = new StructSyntaxNode();
+        RefPtr<StructDecl> blockDataTypeDecl = new StructDecl();
         RefPtr<Variable> blockVarDecl = new Variable();
 
         addModifier(blockDataTypeDecl, new ImplicitParameterBlockElementTypeModifier());
@@ -1977,13 +1977,13 @@ namespace Slang
         // these constructs directly into the AST and *then* desugar them.
 
         // Construct a type expression to reference the buffer data type
-        auto blockDataTypeExpr = new VarExpressionSyntaxNode();
+        auto blockDataTypeExpr = new VarExpr();
         blockDataTypeExpr->Position = blockDataTypeDecl->Position;
         blockDataTypeExpr->name = blockDataTypeDecl->Name.Content;
         blockDataTypeExpr->scope = parser->currentScope.Ptr();
 
         // Construct a type exrpession to reference the type constructor
-        auto blockWrapperTypeExpr = new VarExpressionSyntaxNode();
+        auto blockWrapperTypeExpr = new VarExpr();
         blockWrapperTypeExpr->Position = pos;
         blockWrapperTypeExpr->name = blockWrapperTypeName;
         // Always need to look this up in the outer scope,
@@ -1997,7 +1997,7 @@ namespace Slang
         blockVarTypeExpr->FunctionExpr = blockWrapperTypeExpr;
         blockVarTypeExpr->Arguments.Add(blockDataTypeExpr);
 
-        blockVarDecl->Type.exp = blockVarTypeExpr;
+        blockVarDecl->type.exp = blockVarTypeExpr;
 
         // The declarations in the body belong to the data type.
         parseAggTypeDeclBody(parser, blockDataTypeDecl.Ptr());
@@ -2056,11 +2056,11 @@ namespace Slang
             paramDecl->Name = parser->ReadToken(TokenType::Identifier);
             if (AdvanceIf(parser, TokenType::Colon))
             {
-                paramDecl->Type = parser->ParseTypeExp();
+                paramDecl->type = parser->ParseTypeExp();
             }
             if (AdvanceIf(parser, TokenType::OpAssign))
             {
-                paramDecl->Expr = parser->ParseInitExpr();
+                paramDecl->initExpr = parser->ParseInitExpr();
             }
             return paramDecl;
         }
@@ -2084,7 +2084,7 @@ namespace Slang
                 auto paramTypeExpr = new SharedTypeExpr();
                 paramTypeExpr->Position = paramDecl->Position;
                 paramTypeExpr->base.type = paramType;
-                paramTypeExpr->Type = QualType(getTypeType(paramType));
+                paramTypeExpr->type = QualType(getTypeType(paramType));
 
                 paramConstraint->sub = TypeExp(paramTypeExpr);
                 paramConstraint->sup = parser->ParseTypeExp();
@@ -2438,7 +2438,7 @@ namespace Slang
     }
 
 
-    void Parser::parseSourceFile(ProgramSyntaxNode* program)
+    void Parser::parseSourceFile(ModuleDecl* program)
     {
         if (outerScope)
         {
@@ -2454,18 +2454,18 @@ namespace Slang
         currentScope = nullptr;
     }
 
-    RefPtr<ProgramSyntaxNode> Parser::ParseProgram()
+    RefPtr<ModuleDecl> Parser::ParseProgram()
     {
-        RefPtr<ProgramSyntaxNode> program = new ProgramSyntaxNode();
+        RefPtr<ModuleDecl> program = new ModuleDecl();
 
         parseSourceFile(program.Ptr());
 
         return program;
     }
 
-    RefPtr<StructSyntaxNode> Parser::ParseStruct()
+    RefPtr<StructDecl> Parser::ParseStruct()
     {
-        RefPtr<StructSyntaxNode> rs = new StructSyntaxNode();
+        RefPtr<StructDecl> rs = new StructDecl();
         FillPosition(rs.Ptr());
         ReadToken("struct");
 
@@ -2481,9 +2481,9 @@ namespace Slang
         return rs;
     }
 
-    RefPtr<ClassSyntaxNode> Parser::ParseClass()
+    RefPtr<ClassDecl> Parser::ParseClass()
     {
-        RefPtr<ClassSyntaxNode> rs = new ClassSyntaxNode();
+        RefPtr<ClassDecl> rs = new ClassDecl();
         FillPosition(rs.Ptr());
         ReadToken("class");
         rs->Name = ReadToken(TokenType::Identifier);
@@ -2493,7 +2493,7 @@ namespace Slang
         return rs;
     }
 
-    static RefPtr<StatementSyntaxNode> ParseSwitchStmt(Parser* parser)
+    static RefPtr<Stmt> ParseSwitchStmt(Parser* parser)
     {
         RefPtr<SwitchStmt> stmt = new SwitchStmt();
         parser->FillPosition(stmt.Ptr());
@@ -2505,7 +2505,7 @@ namespace Slang
         return stmt;
     }
 
-    static RefPtr<StatementSyntaxNode> ParseCaseStmt(Parser* parser)
+    static RefPtr<Stmt> ParseCaseStmt(Parser* parser)
     {
         RefPtr<CaseStmt> stmt = new CaseStmt();
         parser->FillPosition(stmt.Ptr());
@@ -2515,7 +2515,7 @@ namespace Slang
         return stmt;
     }
 
-    static RefPtr<StatementSyntaxNode> ParseDefaultStmt(Parser* parser)
+    static RefPtr<Stmt> ParseDefaultStmt(Parser* parser)
     {
         RefPtr<DefaultStmt> stmt = new DefaultStmt();
         parser->FillPosition(stmt.Ptr());
@@ -2580,7 +2580,7 @@ namespace Slang
         return isTypeName(parser, name);
     }
 
-    RefPtr<StatementSyntaxNode> parseCompileTimeForStmt(
+    RefPtr<Stmt> parseCompileTimeForStmt(
         Parser* parser)
     {
         RefPtr<ScopeDecl> scopeDecl = new ScopeDecl();
@@ -2602,8 +2602,8 @@ namespace Slang
         parser->ReadToken("Range");
         parser->ReadToken(TokenType::LParent);
 
-        RefPtr<ExpressionSyntaxNode> rangeBeginExpr;
-        RefPtr<ExpressionSyntaxNode> rangeEndExpr = parser->ParseArgExpr();
+        RefPtr<Expr> rangeBeginExpr;
+        RefPtr<Expr> rangeEndExpr = parser->ParseArgExpr();
         if (AdvanceIf(parser, TokenType::Comma))
         {
             rangeBeginExpr = rangeEndExpr;
@@ -2626,7 +2626,7 @@ namespace Slang
         return stmt;
     }
 
-    RefPtr<StatementSyntaxNode> parseCompileTimeStmt(
+    RefPtr<Stmt> parseCompileTimeStmt(
         Parser* parser)
     {
         parser->ReadToken(TokenType::Dollar);
@@ -2641,11 +2641,11 @@ namespace Slang
         }
     }
 
-    RefPtr<StatementSyntaxNode> Parser::ParseStatement()
+    RefPtr<Stmt> Parser::ParseStatement()
     {
         auto modifiers = ParseModifiers(this);
 
-        RefPtr<StatementSyntaxNode> statement;
+        RefPtr<Stmt> statement;
         if (LookAheadToken(TokenType::LBrace))
             statement = ParseBlockStatement();
         else if (peekTypeName(this))
@@ -2666,7 +2666,7 @@ namespace Slang
             statement = ParseReturnStatement();
         else if (LookAheadToken("discard"))
         {
-            statement = new DiscardStatementSyntaxNode();
+            statement = new DiscardStmt();
             FillPosition(statement.Ptr());
             ReadToken("discard");
             ReadToken(TokenType::Semicolon);
@@ -2693,7 +2693,7 @@ namespace Slang
             // Try to parse a type (knowing that the type grammar is
             // a subset of the expression grammar, and so this should
             // always succeed).
-            RefPtr<ExpressionSyntaxNode> type = ParseType();
+            RefPtr<Expr> type = ParseType();
             // We don't actually care about the type, though, so
             // don't retain it
             type = nullptr;
@@ -2721,7 +2721,7 @@ namespace Slang
         }
         else if (LookAheadToken(TokenType::Semicolon))
         {
-            statement = new EmptyStatementSyntaxNode();
+            statement = new EmptyStmt();
             FillPosition(statement.Ptr());
             ReadToken(TokenType::Semicolon);
         }
@@ -2744,7 +2744,7 @@ namespace Slang
         return statement;
     }
 
-    RefPtr<StatementSyntaxNode> Parser::ParseBlockStatement()
+    RefPtr<Stmt> Parser::ParseBlockStatement()
     {
         // If we are being asked not to check things *and* we haven't
         // seen any `import` declarations yet, then we can safely assume
@@ -2799,7 +2799,7 @@ namespace Slang
         PushScope(scopeDecl.Ptr());
         ReadToken(TokenType::LBrace);
 
-        RefPtr<StatementSyntaxNode> body;
+        RefPtr<Stmt> body;
 
         if(!tokenReader.IsAtEnd())
         {
@@ -2836,10 +2836,10 @@ namespace Slang
         return blockStatement;
     }
 
-    RefPtr<VarDeclrStatementSyntaxNode> Parser::ParseVarDeclrStatement(
+    RefPtr<DeclStmt> Parser::ParseVarDeclrStatement(
         Modifiers modifiers)
     {
-        RefPtr<VarDeclrStatementSyntaxNode>varDeclrStatement = new VarDeclrStatementSyntaxNode();
+        RefPtr<DeclStmt>varDeclrStatement = new DeclStmt();
         
         FillPosition(varDeclrStatement.Ptr());
         auto decl = ParseDeclWithModifiers(this, currentScope->containerDecl, modifiers);
@@ -2847,9 +2847,9 @@ namespace Slang
         return varDeclrStatement;
     }
 
-    RefPtr<IfStatementSyntaxNode> Parser::ParseIfStatement()
+    RefPtr<IfStmt> Parser::ParseIfStatement()
     {
-        RefPtr<IfStatementSyntaxNode> ifStatement = new IfStatementSyntaxNode();
+        RefPtr<IfStmt> ifStatement = new IfStmt();
         FillPosition(ifStatement.Ptr());
         ReadToken("if");
         ReadToken(TokenType::LParent);
@@ -2864,7 +2864,7 @@ namespace Slang
         return ifStatement;
     }
 
-    RefPtr<ForStatementSyntaxNode> Parser::ParseForStatement()
+    RefPtr<ForStmt> Parser::ParseForStatement()
     {
         RefPtr<ScopeDecl> scopeDecl = new ScopeDecl();
 
@@ -2879,14 +2879,14 @@ namespace Slang
         // case, just so that we can correctly handle it in downstream
         // logic.
         //
-        RefPtr<ForStatementSyntaxNode> stmt;
+        RefPtr<ForStmt> stmt;
         if (brokenScoping)
         {
             stmt = new UnscopedForStmt();
         }
         else
         {
-            stmt = new ForStatementSyntaxNode();
+            stmt = new ForStmt();
         }
 
         stmt->scopeDecl = scopeDecl;
@@ -2925,9 +2925,9 @@ namespace Slang
         return stmt;
     }
 
-    RefPtr<WhileStatementSyntaxNode> Parser::ParseWhileStatement()
+    RefPtr<WhileStmt> Parser::ParseWhileStatement()
     {
-        RefPtr<WhileStatementSyntaxNode> whileStatement = new WhileStatementSyntaxNode();
+        RefPtr<WhileStmt> whileStatement = new WhileStmt();
         FillPosition(whileStatement.Ptr());
         ReadToken("while");
         ReadToken(TokenType::LParent);
@@ -2937,9 +2937,9 @@ namespace Slang
         return whileStatement;
     }
 
-    RefPtr<DoWhileStatementSyntaxNode> Parser::ParseDoWhileStatement()
+    RefPtr<DoWhileStmt> Parser::ParseDoWhileStatement()
     {
-        RefPtr<DoWhileStatementSyntaxNode> doWhileStatement = new DoWhileStatementSyntaxNode();
+        RefPtr<DoWhileStmt> doWhileStatement = new DoWhileStmt();
         FillPosition(doWhileStatement.Ptr());
         ReadToken("do");
         doWhileStatement->Statement = ParseStatement();
@@ -2951,27 +2951,27 @@ namespace Slang
         return doWhileStatement;
     }
 
-    RefPtr<BreakStatementSyntaxNode> Parser::ParseBreakStatement()
+    RefPtr<BreakStmt> Parser::ParseBreakStatement()
     {
-        RefPtr<BreakStatementSyntaxNode> breakStatement = new BreakStatementSyntaxNode();
+        RefPtr<BreakStmt> breakStatement = new BreakStmt();
         FillPosition(breakStatement.Ptr());
         ReadToken("break");
         ReadToken(TokenType::Semicolon);
         return breakStatement;
     }
 
-    RefPtr<ContinueStatementSyntaxNode>	Parser::ParseContinueStatement()
+    RefPtr<ContinueStmt>	Parser::ParseContinueStatement()
     {
-        RefPtr<ContinueStatementSyntaxNode> continueStatement = new ContinueStatementSyntaxNode();
+        RefPtr<ContinueStmt> continueStatement = new ContinueStmt();
         FillPosition(continueStatement.Ptr());
         ReadToken("continue");
         ReadToken(TokenType::Semicolon);
         return continueStatement;
     }
 
-    RefPtr<ReturnStatementSyntaxNode> Parser::ParseReturnStatement()
+    RefPtr<ReturnStmt> Parser::ParseReturnStatement()
     {
-        RefPtr<ReturnStatementSyntaxNode> returnStatement = new ReturnStatementSyntaxNode();
+        RefPtr<ReturnStmt> returnStatement = new ReturnStmt();
         FillPosition(returnStatement.Ptr());
         ReadToken("return");
         if (!LookAheadToken(TokenType::Semicolon))
@@ -2980,9 +2980,9 @@ namespace Slang
         return returnStatement;
     }
 
-    RefPtr<ExpressionStatementSyntaxNode> Parser::ParseExpressionStatement()
+    RefPtr<ExpressionStmt> Parser::ParseExpressionStatement()
     {
-        RefPtr<ExpressionStatementSyntaxNode> statement = new ExpressionStatementSyntaxNode();
+        RefPtr<ExpressionStmt> statement = new ExpressionStmt();
             
         FillPosition(statement.Ptr());
         statement->Expression = ParseExpression();
@@ -2991,9 +2991,9 @@ namespace Slang
         return statement;
     }
 
-    RefPtr<ParameterSyntaxNode> Parser::ParseParameter()
+    RefPtr<ParamDecl> Parser::ParseParameter()
     {
-        RefPtr<ParameterSyntaxNode> parameter = new ParameterSyntaxNode();
+        RefPtr<ParamDecl> parameter = new ParamDecl();
         parameter->modifiers = ParseModifiers(this);
 
         DeclaratorInfo declaratorInfo;
@@ -3007,7 +3007,7 @@ namespace Slang
         return parameter;
     }
 
-    RefPtr<ExpressionSyntaxNode> Parser::ParseType()
+    RefPtr<Expr> Parser::ParseType()
     {
         auto typeSpec = parseTypeSpec(this);
         if( typeSpec.decl )
@@ -3103,7 +3103,7 @@ namespace Slang
         }
     }
 
-    static RefPtr<ExpressionSyntaxNode> parseOperator(Parser* parser)
+    static RefPtr<Expr> parseOperator(Parser* parser)
     {
         Token opToken;
         switch(parser->tokenReader.PeekTokenType())
@@ -3118,7 +3118,7 @@ namespace Slang
             break;
         }
 
-        auto opExpr = new VarExpressionSyntaxNode();
+        auto opExpr = new VarExpr();
         opExpr->name = opToken.Content;
         opExpr->scope = parser->currentScope;
         opExpr->Position = opToken.Position;
@@ -3127,11 +3127,11 @@ namespace Slang
 
     }
 
-    static RefPtr<ExpressionSyntaxNode> createInfixExpr(
+    static RefPtr<Expr> createInfixExpr(
         Parser*                         /*parser*/,
-        RefPtr<ExpressionSyntaxNode>    left,
-        RefPtr<ExpressionSyntaxNode>    op,
-        RefPtr<ExpressionSyntaxNode>    right)
+        RefPtr<Expr>    left,
+        RefPtr<Expr>    op,
+        RefPtr<Expr>    right)
     {
         RefPtr<InfixExpr> expr = new InfixExpr();
         expr->Position = op->Position;
@@ -3141,9 +3141,9 @@ namespace Slang
         return expr;
     }
 
-    static RefPtr<ExpressionSyntaxNode> parseInfixExprWithPrecedence(
+    static RefPtr<Expr> parseInfixExprWithPrecedence(
         Parser*                         parser,
-        RefPtr<ExpressionSyntaxNode>    inExpr,
+        RefPtr<Expr>    inExpr,
         Precedence                      prec)
     {
         auto expr = inExpr;
@@ -3160,7 +3160,7 @@ namespace Slang
             // one non-binary case we need to deal with.
             if(opTokenType == TokenType::QuestionMark)
             {
-                RefPtr<SelectExpressionSyntaxNode> select = new SelectExpressionSyntaxNode();
+                RefPtr<SelectExpr> select = new SelectExpr();
                 select->Position = op->Position;
                 select->FunctionExpr = op;
 
@@ -3203,7 +3203,7 @@ namespace Slang
         return expr;
     }
 
-    RefPtr<ExpressionSyntaxNode> Parser::ParseExpression(Precedence level)
+    RefPtr<Expr> Parser::ParseExpression(Precedence level)
     {
         auto expr = ParseLeafExpression();
         return parseInfixExprWithPrecedence(this, expr, level);
@@ -3218,7 +3218,7 @@ namespace Slang
             auto condition = ParseExpression(Precedence(level + 1));
             if (LookAheadToken(TokenType::QuestionMark))
             {
-                RefPtr<SelectExpressionSyntaxNode> select = new SelectExpressionSyntaxNode();
+                RefPtr<SelectExpr> select = new SelectExpr();
                 FillPosition(select.Ptr());
 
                 select->Arguments.Add(condition);
@@ -3240,7 +3240,7 @@ namespace Slang
                 auto left = ParseExpression(Precedence(level + 1));
                 while (GetOpLevel(this, tokenReader.PeekTokenType()) == level)
                 {
-                    RefPtr<OperatorExpressionSyntaxNode> tmp = new InfixExpr();
+                    RefPtr<OperatorExpr> tmp = new InfixExpr();
                     tmp->FunctionExpr = parseOperator(this);
 
                     tmp->Arguments.Add(left);
@@ -3255,7 +3255,7 @@ namespace Slang
                 auto left = ParseExpression(Precedence(level + 1));
                 if (GetOpLevel(this, tokenReader.PeekTokenType()) == level)
                 {
-                    RefPtr<OperatorExpressionSyntaxNode> tmp = new InfixExpr();
+                    RefPtr<OperatorExpr> tmp = new InfixExpr();
                     tmp->Arguments.Add(left);
                     FillPosition(tmp.Ptr());
                     tmp->FunctionExpr = parseOperator(this);
@@ -3270,11 +3270,11 @@ namespace Slang
 
     // We *might* be looking at an application of a generic to arguments,
     // but we need to disambiguate to make sure.
-    static RefPtr<ExpressionSyntaxNode> maybeParseGenericApp(
+    static RefPtr<Expr> maybeParseGenericApp(
         Parser*                             parser,
 
         // TODO: need to support more general expressions here
-        RefPtr<VarExpressionSyntaxNode>     base)
+        RefPtr<VarExpr>     base)
     {
         if(peekTokenType(parser) != TokenType::OpLess)
             return base;
@@ -3287,7 +3287,7 @@ namespace Slang
         return parseGenericApp(parser, base);
     }
 
-    static RefPtr<ExpressionSyntaxNode> parseAtomicExpr(Parser* parser)
+    static RefPtr<Expr> parseAtomicExpr(Parser* parser)
     {
         switch( peekTokenType(parser) )
         {
@@ -3309,7 +3309,7 @@ namespace Slang
 
                 if (peekTypeName(parser) && parser->LookAheadToken(TokenType::RParent, 1))
                 {
-                    RefPtr<TypeCastExpressionSyntaxNode> tcexpr = new ExplicitCastExpr();
+                    RefPtr<TypeCastExpr> tcexpr = new ExplicitCastExpr();
                     parser->FillPosition(tcexpr.Ptr());
                     tcexpr->TargetType = parser->ParseTypeExp();
                     parser->ReadToken(TokenType::RParent);
@@ -3318,7 +3318,7 @@ namespace Slang
                 }
                 else
                 {
-                    RefPtr<ExpressionSyntaxNode> base = parser->ParseExpression();
+                    RefPtr<Expr> base = parser->ParseExpression();
                     parser->ReadToken(TokenType::RParent);
 
                     RefPtr<ParenExpr> parenExpr = new ParenExpr();
@@ -3337,7 +3337,7 @@ namespace Slang
                 // Initializer list
                 parser->ReadToken(TokenType::LBrace);
 
-                List<RefPtr<ExpressionSyntaxNode>> exprs;
+                List<RefPtr<Expr>> exprs;
 
                 for(;;)
                 {
@@ -3361,7 +3361,7 @@ namespace Slang
 
         case TokenType::IntegerLiteral:
             {
-                RefPtr<ConstantExpressionSyntaxNode> constExpr = new ConstantExpressionSyntaxNode();
+                RefPtr<ConstantExpr> constExpr = new ConstantExpr();
                 parser->FillPosition(constExpr.Ptr());
 
                 auto token = parser->tokenReader.AdvanceToken();
@@ -3373,7 +3373,7 @@ namespace Slang
                 // Look at any suffix on the value
                 char const* suffixCursor = suffix.begin();
 
-                RefPtr<ExpressionType> suffixType = nullptr;
+                RefPtr<Type> suffixType = nullptr;
                 if( suffixCursor && *suffixCursor )
                 {
                     int lCount = 0;
@@ -3421,9 +3421,9 @@ namespace Slang
                     }
                 }
 
-                constExpr->ConstType = ConstantExpressionSyntaxNode::ConstantType::Int;
+                constExpr->ConstType = ConstantExpr::ConstantType::Int;
                 constExpr->integerValue = value;
-                constExpr->Type = QualType(suffixType);
+                constExpr->type = QualType(suffixType);
 
                 return constExpr;
             }
@@ -3431,7 +3431,7 @@ namespace Slang
 
         case TokenType::FloatingPointLiteral:
             {
-                RefPtr<ConstantExpressionSyntaxNode> constExpr = new ConstantExpressionSyntaxNode();
+                RefPtr<ConstantExpr> constExpr = new ConstantExpr();
                 parser->FillPosition(constExpr.Ptr());
 
                 auto token = parser->tokenReader.AdvanceToken();
@@ -3443,7 +3443,7 @@ namespace Slang
                 // Look at any suffix on the value
                 char const* suffixCursor = suffix.begin();
 
-                RefPtr<ExpressionType> suffixType = nullptr;
+                RefPtr<Type> suffixType = nullptr;
                 if( suffixCursor && *suffixCursor )
                 {
                     int fCount = 0;
@@ -3490,20 +3490,20 @@ namespace Slang
                     }
                 }
 
-                constExpr->ConstType = ConstantExpressionSyntaxNode::ConstantType::Float;
+                constExpr->ConstType = ConstantExpr::ConstantType::Float;
                 constExpr->floatingPointValue = value;
-                constExpr->Type = QualType(suffixType);
+                constExpr->type = QualType(suffixType);
 
                 return constExpr;
             }
 
         case TokenType::StringLiteral:
             {
-                RefPtr<ConstantExpressionSyntaxNode> constExpr = new ConstantExpressionSyntaxNode();
+                RefPtr<ConstantExpr> constExpr = new ConstantExpr();
                 auto token = parser->tokenReader.AdvanceToken();
                 constExpr->token = token;
                 parser->FillPosition(constExpr.Ptr());
-                constExpr->ConstType = ConstantExpressionSyntaxNode::ConstantType::String;
+                constExpr->ConstType = ConstantExpr::ConstantType::String;
 
                 if (!parser->LookAheadToken(TokenType::StringLiteral))
                 {
@@ -3532,18 +3532,18 @@ namespace Slang
 
                 if (parser->LookAheadToken("true") || parser->LookAheadToken("false"))
                 {
-                    RefPtr<ConstantExpressionSyntaxNode> constExpr = new ConstantExpressionSyntaxNode();
+                    RefPtr<ConstantExpr> constExpr = new ConstantExpr();
                     auto token = parser->tokenReader.AdvanceToken();
                     constExpr->token = token;
                     parser->FillPosition(constExpr.Ptr());
-                    constExpr->ConstType = ConstantExpressionSyntaxNode::ConstantType::Bool;
+                    constExpr->ConstType = ConstantExpr::ConstantType::Bool;
                     constExpr->integerValue = token.Content == "true" ? 1 : 0;
 
                     return constExpr;
                 }
 
                 // Default behavior is just to create a name expression
-                RefPtr<VarExpressionSyntaxNode> varExpr = new VarExpressionSyntaxNode();
+                RefPtr<VarExpr> varExpr = new VarExpr();
                 varExpr->scope = parser->currentScope.Ptr();
                 parser->FillPosition(varExpr.Ptr());
                 auto token = parser->ReadToken(TokenType::Identifier);
@@ -3559,7 +3559,7 @@ namespace Slang
         }
     }
 
-    static RefPtr<ExpressionSyntaxNode> parsePostfixExpr(Parser* parser)
+    static RefPtr<Expr> parsePostfixExpr(Parser* parser)
     {
         auto expr = parseAtomicExpr(parser);
         for(;;)
@@ -3573,7 +3573,7 @@ namespace Slang
             case TokenType::OpInc:
             case TokenType::OpDec:
                 {
-                    RefPtr<OperatorExpressionSyntaxNode> postfixExpr = new PostfixExpr();
+                    RefPtr<OperatorExpr> postfixExpr = new PostfixExpr();
                     parser->FillPosition(postfixExpr.Ptr());
                     postfixExpr->FunctionExpr = parseOperator(parser);
                     postfixExpr->Arguments.Add(expr);
@@ -3585,7 +3585,7 @@ namespace Slang
             // Subscript operation `a[i]`
             case TokenType::LBracket:
                 {
-                    RefPtr<IndexExpressionSyntaxNode> indexExpr = new IndexExpressionSyntaxNode();
+                    RefPtr<IndexExpr> indexExpr = new IndexExpr();
                     indexExpr->BaseExpression = expr;
                     parser->FillPosition(indexExpr.Ptr());
                     parser->ReadToken(TokenType::LBracket);
@@ -3603,7 +3603,7 @@ namespace Slang
             // Call oepration `f(x)`
             case TokenType::LParent:
                 {
-                    RefPtr<InvokeExpressionSyntaxNode> invokeExpr = new InvokeExpressionSyntaxNode();
+                    RefPtr<InvokeExpr> invokeExpr = new InvokeExpr();
                     invokeExpr->FunctionExpr = expr;
                     parser->FillPosition(invokeExpr.Ptr());
                     parser->ReadToken(TokenType::LParent);
@@ -3628,7 +3628,7 @@ namespace Slang
             // Member access `x.m`
             case TokenType::Dot:
                 {
-                    RefPtr<MemberExpressionSyntaxNode> memberExpr = new MemberExpressionSyntaxNode();
+                    RefPtr<MemberExpr> memberExpr = new MemberExpr();
 
                     // TODO(tfoley): why would a member expression need this?
                     memberExpr->scope = parser->currentScope.Ptr();
@@ -3645,7 +3645,7 @@ namespace Slang
         }
     }
 
-    static RefPtr<ExpressionSyntaxNode> parsePrefixExpr(Parser* parser)
+    static RefPtr<Expr> parsePrefixExpr(Parser* parser)
     {
         switch( peekTokenType(parser) )
         {
@@ -3669,19 +3669,19 @@ namespace Slang
         }
     }
 
-    RefPtr<ExpressionSyntaxNode> Parser::ParseLeafExpression()
+    RefPtr<Expr> Parser::ParseLeafExpression()
     {
         return parsePrefixExpr(this);
 
 #if 0
-        RefPtr<ExpressionSyntaxNode> rs;
+        RefPtr<Expr> rs;
         if (LookAheadToken(TokenType::OpInc) ||
             LookAheadToken(TokenType::OpDec) ||
             LookAheadToken(TokenType::OpNot) ||
             LookAheadToken(TokenType::OpBitNot) ||
             LookAheadToken(TokenType::OpSub))
         {
-            RefPtr<OperatorExpressionSyntaxNode> unaryExpr = new PrefixExpr();
+            RefPtr<OperatorExpr> unaryExpr = new PrefixExpr();
             FillPosition(unaryExpr.Ptr());
             unaryExpr->FunctionExpr = parseOperator(this);
             unaryExpr->Arguments.Add(ParseLeafExpression());
@@ -3692,10 +3692,10 @@ namespace Slang
         if (LookAheadToken(TokenType::LParent))
         {
             ReadToken(TokenType::LParent);
-            RefPtr<ExpressionSyntaxNode> expr;
+            RefPtr<Expr> expr;
             if (peekTypeName(this) && LookAheadToken(TokenType::RParent, 1))
             {
-                RefPtr<TypeCastExpressionSyntaxNode> tcexpr = new TypeCastExpressionSyntaxNode();
+                RefPtr<TypeCastExpr> tcexpr = new TypeCastExpr();
                 FillPosition(tcexpr.Ptr());
                 tcexpr->TargetType = ParseTypeExp();
                 ReadToken(TokenType::RParent);
@@ -3717,7 +3717,7 @@ namespace Slang
             // Initializer list
             ReadToken(TokenType::LBrace);
 
-            List<RefPtr<ExpressionSyntaxNode>> exprs;
+            List<RefPtr<Expr>> exprs;
 
             for(;;)
             {
@@ -3741,33 +3741,33 @@ namespace Slang
         else if (LookAheadToken(TokenType::IntegerLiteral) ||
             LookAheadToken(TokenType::FloatingPointLiteral))
         {
-            RefPtr<ConstantExpressionSyntaxNode> constExpr = new ConstantExpressionSyntaxNode();
+            RefPtr<ConstantExpr> constExpr = new ConstantExpr();
             auto token = tokenReader.AdvanceToken();
             FillPosition(constExpr.Ptr());
-            if (token.Type == TokenType::IntegerLiteral)
+            if (token.type == TokenType::IntegerLiteral)
             {
-                constExpr->ConstType = ConstantExpressionSyntaxNode::ConstantType::Int;
+                constExpr->ConstType = ConstantExpr::ConstantType::Int;
                 constExpr->IntValue = StringToInt(token.Content);
             }
-            else if (token.Type == TokenType::FloatingPointLiteral)
+            else if (token.type == TokenType::FloatingPointLiteral)
             {
-                constExpr->ConstType = ConstantExpressionSyntaxNode::ConstantType::Float;
+                constExpr->ConstType = ConstantExpr::ConstantType::Float;
                 constExpr->FloatValue = (FloatingPointLiteralValue) StringToDouble(token.Content);
             }
             rs = constExpr;
         }
         else if (LookAheadToken("true") || LookAheadToken("false"))
         {
-            RefPtr<ConstantExpressionSyntaxNode> constExpr = new ConstantExpressionSyntaxNode();
+            RefPtr<ConstantExpr> constExpr = new ConstantExpr();
             auto token = tokenReader.AdvanceToken();
             FillPosition(constExpr.Ptr());
-            constExpr->ConstType = ConstantExpressionSyntaxNode::ConstantType::Bool;
+            constExpr->ConstType = ConstantExpr::ConstantType::Bool;
             constExpr->IntValue = token.Content == "true" ? 1 : 0;
             rs = constExpr;
         }
         else if (LookAheadToken(TokenType::Identifier))
         {
-            RefPtr<VarExpressionSyntaxNode> varExpr = new VarExpressionSyntaxNode();
+            RefPtr<VarExpr> varExpr = new VarExpr();
             varExpr->scope = currentScope.Ptr();
             FillPosition(varExpr.Ptr());
             auto token = ReadToken(TokenType::Identifier);
@@ -3784,7 +3784,7 @@ namespace Slang
         {
             if (LookAheadToken(TokenType::OpInc))
             {
-                RefPtr<OperatorExpressionSyntaxNode> unaryExpr = new PostfixExpr();
+                RefPtr<OperatorExpr> unaryExpr = new PostfixExpr();
                 FillPosition(unaryExpr.Ptr());
                 unaryExpr->FunctionExpr = parseOperator(this);
                 unaryExpr->Arguments.Add(rs);
@@ -3792,7 +3792,7 @@ namespace Slang
             }
             else if (LookAheadToken(TokenType::OpDec))
             {
-                RefPtr<OperatorExpressionSyntaxNode> unaryExpr = new PostfixExpr();
+                RefPtr<OperatorExpr> unaryExpr = new PostfixExpr();
                 FillPosition(unaryExpr.Ptr());
                 unaryExpr->FunctionExpr = parseOperator(this);
                 unaryExpr->Arguments.Add(rs);
@@ -3800,7 +3800,7 @@ namespace Slang
             }
             else if (LookAheadToken(TokenType::LBracket))
             {
-                RefPtr<IndexExpressionSyntaxNode> indexExpr = new IndexExpressionSyntaxNode();
+                RefPtr<IndexExpr> indexExpr = new IndexExpr();
                 indexExpr->BaseExpression = rs;
                 FillPosition(indexExpr.Ptr());
                 ReadToken(TokenType::LBracket);
@@ -3810,7 +3810,7 @@ namespace Slang
             }
             else if (LookAheadToken(TokenType::LParent))
             {
-                RefPtr<InvokeExpressionSyntaxNode> invokeExpr = new InvokeExpressionSyntaxNode();
+                RefPtr<InvokeExpr> invokeExpr = new InvokeExpr();
                 invokeExpr->FunctionExpr = rs;
                 FillPosition(invokeExpr.Ptr());
                 ReadToken(TokenType::LParent);
@@ -3831,7 +3831,7 @@ namespace Slang
             }
             else if (LookAheadToken(TokenType::Dot))
             {
-                RefPtr<MemberExpressionSyntaxNode> memberExpr = new MemberExpressionSyntaxNode();
+                RefPtr<MemberExpr> memberExpr = new MemberExpr();
                 memberExpr->scope = currentScope.Ptr();
                 FillPosition(memberExpr.Ptr());
                 memberExpr->BaseExpression = rs;
diff --git a/source/slang/preprocessor.cpp b/source/slang/preprocessor.cpp
index ec38a7214..53f0c4774 100644
--- a/source/slang/preprocessor.cpp
+++ b/source/slang/preprocessor.cpp
@@ -175,7 +175,7 @@ struct Preprocessor
         return translationUnit;
     }
 
-    ProgramSyntaxNode* getSyntax()
+    ModuleDecl* getSyntax()
     {
         return getTranslationUnit()->SyntaxNode.Ptr();
     }
@@ -411,7 +411,7 @@ static CodePosition PeekLoc(Preprocessor* preprocessor)
 // Get the `TokenType` of the current (raw) token
 static TokenType PeekRawTokenType(Preprocessor* preprocessor)
 {
-    return PeekRawToken(preprocessor).Type;
+    return PeekRawToken(preprocessor).type;
 }
 
 //
@@ -546,7 +546,7 @@ static void AddEndOfStreamToken(
     PreprocessorMacro*  macro)
 {
     Token token = PeekRawToken(preprocessor);
-    token.Type = TokenType::EndOfFile;
+    token.type = TokenType::EndOfFile;
     macro->tokens.mTokens.Add(token);
 }
 
@@ -564,7 +564,7 @@ static void MaybeBeginMacroExpansion(
         Token const& token = PeekRawToken(preprocessor);
 
         // Not an identifier? Can't be a macro.
-        if (token.Type != TokenType::Identifier)
+        if (token.type != TokenType::Identifier)
             return;
 
         // Look for a macro with the given name.
@@ -795,7 +795,7 @@ static Token PeekToken(Preprocessor* preprocessor)
 // Peek the type of the next token, including macro expansion.
 static TokenType PeekTokenType(Preprocessor* preprocessor)
 {
-    return PeekToken(preprocessor).Type;
+    return PeekToken(preprocessor).type;
 }
 
 //
@@ -865,7 +865,7 @@ static PreprocessorMacro* LookupMacro(PreprocessorDirectiveContext* context, Str
 // Determine if we have read everthing on the directive's line.
 static bool IsEndOfLine(PreprocessorDirectiveContext* context)
 {
-    return PeekRawToken(context->preprocessor).Type == TokenType::EndOfDirective;
+    return PeekRawToken(context->preprocessor).type == TokenType::EndOfDirective;
 }
 
 // Peek one raw token in a directive, without going past the end of the line.
@@ -1108,7 +1108,7 @@ static PreprocessorExpressionValue ParseAndEvaluateUnaryExpression(PreprocessorD
                 String name = nameToken.Content;
 
                 // If we saw an opening `(`, then expect one to close
-                if (leftParen.Type != TokenType::Unknown)
+                if (leftParen.type != TokenType::Unknown)
                 {
                     if(!ExpectRaw(context, TokenType::RParent, Diagnostics::expectedTokenInDefinedExpression))
                     {
@@ -1143,7 +1143,7 @@ static int GetInfixOpPrecedence(Token const& opToken)
 
     // otherwise we look at the token type to figure
     // out what precednece it should be parse with
-    switch (opToken.Type)
+    switch (opToken.type)
     {
     default:
         // tokens that aren't infix operators should
@@ -1184,7 +1184,7 @@ static PreprocessorExpressionValue EvaluateInfixOp(
     PreprocessorExpressionValue     left,
     PreprocessorExpressionValue     right)
 {
-    switch (opToken.Type)
+    switch (opToken.type)
     {
     default:
 //        SLANG_INTERNAL_ERROR(getSink(preprocessor), opToken);
@@ -1356,7 +1356,7 @@ static void HandleElseDirective(PreprocessorDirectiveContext* context)
     }
 
     // if we've already seen a `#else`, then it is an error
-    if (conditional->elseToken.Type != TokenType::Unknown)
+    if (conditional->elseToken.type != TokenType::Unknown)
     {
         GetSink(context)->diagnose(GetDirectiveLoc(context), Diagnostics::directiveAfterElse, GetDirectiveName(context));
         GetSink(context)->diagnose(conditional->elseToken.Position, Diagnostics::seeDirective);
@@ -1410,7 +1410,7 @@ static void HandleElifDirective(PreprocessorDirectiveContext* context)
     }
 
     // if we've already seen a `#else`, then it is an error
-    if (conditional->elseToken.Type != TokenType::Unknown)
+    if (conditional->elseToken.type != TokenType::Unknown)
     {
         GetSink(context)->diagnose(GetDirectiveLoc(context), Diagnostics::directiveAfterElse, GetDirectiveName(context));
         GetSink(context)->diagnose(conditional->elseToken.Position, Diagnostics::seeDirective);
@@ -1597,11 +1597,11 @@ static void HandleDefineDirective(PreprocessorDirectiveContext* context)
     for(;;)
     {
         Token token = AdvanceRawToken(context);
-        if( token.Type == TokenType::EndOfDirective )
+        if( token.type == TokenType::EndOfDirective )
         {
             // Last token on line will be turned into a conceptual end-of-file
             // token for the sub-stream that the macro expands into.
-            token.Type = TokenType::EndOfFile;
+            token.type = TokenType::EndOfFile;
             macro->tokens.mTokens.Add(token);
             break;
         }
@@ -1876,7 +1876,7 @@ static void HandleDirective(PreprocessorDirectiveContext* context)
     // Try to read the directive name.
     context->directiveToken = PeekRawToken(context);
 
-    TokenType directiveTokenType = GetDirective(context).Type;
+    TokenType directiveTokenType = GetDirective(context).type;
 
     // An empty directive is allowed, and ignored.
     if (directiveTokenType == TokenType::EndOfDirective)
@@ -1920,12 +1920,12 @@ static Token ReadToken(Preprocessor* preprocessor)
     {
         // Look at the next raw token in the input.
         Token const& token = PeekRawToken(preprocessor);
-        if (token.Type == TokenType::EndOfFile)
+        if (token.type == TokenType::EndOfFile)
             return token;
 
 
         // If we have a directive (`#` at start of line) then handle it
-        if ((token.Type == TokenType::Pound) && (token.flags & TokenFlag::AtStartOfLine))
+        if ((token.type == TokenType::Pound) && (token.flags & TokenFlag::AtStartOfLine))
         {
             // Skip the `#`
             AdvanceRawToken(preprocessor);
@@ -1960,7 +1960,7 @@ static void InitializePreprocessor(
 {
     preprocessor->sink = sink;
     preprocessor->includeHandler = NULL;
-    preprocessor->endOfFileToken.Type = TokenType::EndOfFile;
+    preprocessor->endOfFileToken.type = TokenType::EndOfFile;
     preprocessor->endOfFileToken.flags = TokenFlag::AtStartOfLine;
 }
 
@@ -2032,7 +2032,7 @@ static TokenList ReadAllTokens(
 
         // Note: we include the EOF token in the list,
         // since that is expected by the `TokenList` type.
-        if (token.Type == TokenType::EndOfFile)
+        if (token.type == TokenType::EndOfFile)
             break;
     }
     return tokens;
@@ -2183,14 +2183,14 @@ static void HandleImportDirective(PreprocessorDirectiveContext* context)
     SourceTextInputStream* inputStream = new SourceTextInputStream();
  
     Token token;
-    token.Type = TokenType::PoundImport;
+    token.type = TokenType::PoundImport;
     token.Position = GetDirectiveLoc(context);
     token.flags = 0;
     token.Content = foundPath;
  
     inputStream->lexedTokens.mTokens.Add(token);
  
-    token.Type = TokenType::EndOfFile;
+    token.type = TokenType::EndOfFile;
     token.flags = TokenFlag::AfterWhitespace | TokenFlag::AtStartOfLine;
     inputStream->lexedTokens.mTokens.Add(token);
  
diff --git a/source/slang/preprocessor.h b/source/slang/preprocessor.h
index d23b19773..008707ffb 100644
--- a/source/slang/preprocessor.h
+++ b/source/slang/preprocessor.h
@@ -8,7 +8,7 @@
 namespace Slang {
 
 class DiagnosticSink;
-class ProgramSyntaxNode;
+class ModuleDecl;
 class TranslationUnitRequest;
 
 enum class IncludeResult
diff --git a/source/slang/reflection.cpp b/source/slang/reflection.cpp
index 18cf58a92..13c306d56 100644
--- a/source/slang/reflection.cpp
+++ b/source/slang/reflection.cpp
@@ -19,12 +19,12 @@ using namespace Slang;
 
 // Conversion routines to help with strongly-typed reflection API
 
-static inline ExpressionType* convert(SlangReflectionType* type)
+static inline Type* convert(SlangReflectionType* type)
 {
-    return (ExpressionType*) type;
+    return (Type*) type;
 }
 
-static inline SlangReflectionType* convert(ExpressionType* type)
+static inline SlangReflectionType* convert(Type* type)
 {
     return (SlangReflectionType*) type;
 }
@@ -80,7 +80,7 @@ static inline SlangReflection* convert(ProgramLayout* program)
     return (SlangReflection*) program;
 }
 
-// Type Reflection
+// type Reflection
 
 
 SLANG_API SlangTypeKind spReflectionType_GetKind(SlangReflectionType* inType)
@@ -145,7 +145,7 @@ SLANG_API SlangTypeKind spReflectionType_GetKind(SlangReflectionType* inType)
     else if( auto declRefType = type->As<DeclRefType>() )
     {
         auto declRef = declRefType->declRef;
-        if( auto structDeclRef = declRef.As<StructSyntaxNode>() )
+        if( auto structDeclRef = declRef.As<StructDecl>() )
         {
             return SLANG_TYPE_KIND_STRUCT;
         }
@@ -170,7 +170,7 @@ SLANG_API unsigned int spReflectionType_GetFieldCount(SlangReflectionType* inTyp
     if(auto declRefType = dynamic_cast<DeclRefType*>(type))
     {
         auto declRef = declRefType->declRef;
-        if( auto structDeclRef = declRef.As<StructSyntaxNode>())
+        if( auto structDeclRef = declRef.As<StructDecl>())
         {
             return GetFields(structDeclRef).Count();
         }
@@ -189,7 +189,7 @@ SLANG_API SlangReflectionVariable* spReflectionType_GetFieldByIndex(SlangReflect
     if(auto declRefType = dynamic_cast<DeclRefType*>(type))
     {
         auto declRef = declRefType->declRef;
-        if( auto structDeclRef = declRef.As<StructSyntaxNode>())
+        if( auto structDeclRef = declRef.As<StructDecl>())
         {
             auto fieldDeclRef = GetFields(structDeclRef).ToArray()[index];
             return (SlangReflectionVariable*) fieldDeclRef.getDecl();
@@ -424,7 +424,7 @@ SLANG_API SlangReflectionType* spReflectionType_GetResourceResultType(SlangRefle
     return nullptr;
 }
 
-// Type Layout Reflection
+// type Layout Reflection
 
 SLANG_API SlangReflectionType* spReflectionTypeLayout_GetType(SlangReflectionTypeLayout* inTypeLayout)
 {
@@ -754,7 +754,7 @@ SLANG_API void spReflectionEntryPoint_getComputeThreadGroupSize(
     {
         // Fall back to the GLSL case, which requires a search over global-scope declarations
         // to look for anything with the `local_size_*` qualifier
-        auto module = dynamic_cast<ProgramSyntaxNode*>(entryPointFunc->ParentDecl);
+        auto module = dynamic_cast<ModuleDecl*>(entryPointFunc->ParentDecl);
         if (module)
         {
             for (auto dd : module->Members)
diff --git a/source/slang/reflection.h b/source/slang/reflection.h
index 627ca8382..3eef47c6b 100644
--- a/source/slang/reflection.h
+++ b/source/slang/reflection.h
@@ -24,12 +24,12 @@ String emitReflectionJSON(
 
 //
 
-SlangTypeKind getReflectionTypeKind(ExpressionType* type);
+SlangTypeKind getReflectionTypeKind(Type* type);
 
 SlangTypeKind getReflectionParameterCategory(TypeLayout* typeLayout);
 
-UInt getReflectionFieldCount(ExpressionType* type);
-UInt getReflectionFieldByIndex(ExpressionType* type, UInt index);
+UInt getReflectionFieldCount(Type* type);
+UInt getReflectionFieldByIndex(Type* type, UInt index);
 UInt getReflectionFieldByIndex(TypeLayout* typeLayout, UInt index);
 
 }
diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp
index 03bb6a09b..0dcbf44ea 100644
--- a/source/slang/slang.cpp
+++ b/source/slang/slang.cpp
@@ -112,7 +112,7 @@ void CompileRequest::parseTranslationUnit(
     for(auto& def : translationUnit->preprocessorDefinitions)
         combinedPreprocessorDefinitions.Add(def.Key, def.Value);
 
-    RefPtr<ProgramSyntaxNode> translationUnitSyntax = new ProgramSyntaxNode();
+    RefPtr<ModuleDecl> translationUnitSyntax = new ModuleDecl();
     translationUnit->SyntaxNode = translationUnitSyntax;
 
     for (auto sourceFile : translationUnit->sourceFiles)
@@ -355,7 +355,7 @@ int CompileRequest::addEntryPoint(
     return (int) result;
 }
 
-RefPtr<ProgramSyntaxNode> CompileRequest::loadModule(
+RefPtr<ModuleDecl> CompileRequest::loadModule(
     String const&       name,
     String const&       path,
     String const&       source,
@@ -386,7 +386,7 @@ RefPtr<ProgramSyntaxNode> CompileRequest::loadModule(
 
     //
 
-    RefPtr<ProgramSyntaxNode> moduleDecl = translationUnit->SyntaxNode;
+    RefPtr<ModuleDecl> moduleDecl = translationUnit->SyntaxNode;
 
     mapPathToLoadedModule.Add(path, moduleDecl);
     mapNameToLoadedModules.Add(name, moduleDecl);
@@ -406,7 +406,7 @@ void CompileRequest::handlePoundImport(
     // Imported code is always native Slang code
     RefPtr<Scope> languageScope = mSession->slangLanguageScope;
 
-    RefPtr<ProgramSyntaxNode> translationUnitSyntax = new ProgramSyntaxNode();
+    RefPtr<ModuleDecl> translationUnitSyntax = new ModuleDecl();
     translationUnit->SyntaxNode = translationUnitSyntax;
 
     parseSourceFile(
@@ -424,7 +424,7 @@ void CompileRequest::handlePoundImport(
 
     //
 
-    RefPtr<ProgramSyntaxNode> moduleDecl = translationUnit->SyntaxNode;
+    RefPtr<ModuleDecl> moduleDecl = translationUnit->SyntaxNode;
 
     // TODO: It is a bit broken here that we use the module path,
     // as the "name" when registering things, but this saves
@@ -436,13 +436,13 @@ void CompileRequest::handlePoundImport(
     loadedModulesList.Add(moduleDecl);
 }
 
-RefPtr<ProgramSyntaxNode> CompileRequest::findOrImportModule(
+RefPtr<ModuleDecl> CompileRequest::findOrImportModule(
     String const&       name,
     CodePosition const& loc)
 {
     // Have we already loaded a module matching this name?
     // If so, return it.
-    RefPtr<ProgramSyntaxNode> moduleDecl;
+    RefPtr<ModuleDecl> moduleDecl;
     if (mapNameToLoadedModules.TryGetValue(name, moduleDecl))
         return moduleDecl;
 
@@ -505,7 +505,7 @@ RefPtr<ProgramSyntaxNode> CompileRequest::findOrImportModule(
         loc);
 }
 
-RefPtr<ProgramSyntaxNode> findOrImportModule(
+RefPtr<ModuleDecl> findOrImportModule(
     CompileRequest*     request,
     String const&       name,
     CodePosition const& loc)
diff --git a/source/slang/slang.natvis b/source/slang/slang.natvis
index 4f64baf6e..6a9f0cbbc 100644
--- a/source/slang/slang.natvis
+++ b/source/slang/slang.natvis
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?> 
 <AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
-  <Type Name="Slang::CFGNode">
+  <type Name="Slang::CFGNode">
     <DisplayString>{{CFG Basic Block}}</DisplayString>
     <Expand>
       <LinkedListItems>
@@ -10,5 +10,5 @@
         <ValueNode>Value</ValueNode>
       </LinkedListItems>
     </Expand>
-  </Type>
+  </type>
 </AutoVisualizer>
\ No newline at end of file
diff --git a/source/slang/stmt-defs.h b/source/slang/stmt-defs.h
index 80e3cd60d..a9877c281 100644
--- a/source/slang/stmt-defs.h
+++ b/source/slang/stmt-defs.h
@@ -2,39 +2,39 @@
 
 // Syntax class definitions for statements.
 
-ABSTRACT_SYNTAX_CLASS(ScopeStmt, StatementSyntaxNode)
+ABSTRACT_SYNTAX_CLASS(ScopeStmt, Stmt)
     SYNTAX_FIELD(RefPtr<ScopeDecl>, scopeDecl)
 END_SYNTAX_CLASS()
 
 // A sequence of statements, treated as a single statement
-SYNTAX_CLASS(SeqStmt, StatementSyntaxNode)
-    SYNTAX_FIELD(List<RefPtr<StatementSyntaxNode>>, stmts)
+SYNTAX_CLASS(SeqStmt, Stmt)
+    SYNTAX_FIELD(List<RefPtr<Stmt>>, stmts)
 END_SYNTAX_CLASS()
 
 // The simplest kind of scope statement: just a `{...}` block
 SYNTAX_CLASS(BlockStmt, ScopeStmt)
-    SYNTAX_FIELD(RefPtr<StatementSyntaxNode>, body);
+    SYNTAX_FIELD(RefPtr<Stmt>, body);
 END_SYNTAX_CLASS()
 
 // A statement that we aren't going to parse or check, because
 // we want to let a downstream compiler handle any issues
-SYNTAX_CLASS(UnparsedStmt, StatementSyntaxNode)
+SYNTAX_CLASS(UnparsedStmt, Stmt)
     // The tokens that were contained between `{` and `}`
     FIELD(List<Token>, tokens)
 END_SYNTAX_CLASS()
 
-SIMPLE_SYNTAX_CLASS(EmptyStatementSyntaxNode, StatementSyntaxNode)
+SIMPLE_SYNTAX_CLASS(EmptyStmt, Stmt)
 
-SIMPLE_SYNTAX_CLASS(DiscardStatementSyntaxNode, StatementSyntaxNode)
+SIMPLE_SYNTAX_CLASS(DiscardStmt, Stmt)
 
-SYNTAX_CLASS(VarDeclrStatementSyntaxNode, StatementSyntaxNode)
+SYNTAX_CLASS(DeclStmt, Stmt)
     SYNTAX_FIELD(RefPtr<DeclBase>, decl)
 END_SYNTAX_CLASS()
 
-SYNTAX_CLASS(IfStatementSyntaxNode, StatementSyntaxNode)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, Predicate)
-    SYNTAX_FIELD(RefPtr<StatementSyntaxNode>, PositiveStatement)
-    SYNTAX_FIELD(RefPtr<StatementSyntaxNode>, NegativeStatement)
+SYNTAX_CLASS(IfStmt, Stmt)
+    SYNTAX_FIELD(RefPtr<Expr>, Predicate)
+    SYNTAX_FIELD(RefPtr<Stmt>, PositiveStatement)
+    SYNTAX_FIELD(RefPtr<Stmt>, NegativeStatement)
 END_SYNTAX_CLASS()
 
 // A statement that can be escaped with a `break`
@@ -42,15 +42,15 @@ ABSTRACT_SYNTAX_CLASS(BreakableStmt, ScopeStmt)
 END_SYNTAX_CLASS()
 
 SYNTAX_CLASS(SwitchStmt, BreakableStmt)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, condition)
-    SYNTAX_FIELD(RefPtr<StatementSyntaxNode>, body)
+    SYNTAX_FIELD(RefPtr<Expr>, condition)
+    SYNTAX_FIELD(RefPtr<Stmt>, body)
 END_SYNTAX_CLASS()
 
 // A statement that is expected to appear lexically nested inside
 // some other construct, and thus needs to keep track of the
 // outer statement that it is associated with...
-ABSTRACT_SYNTAX_CLASS(ChildStmt, StatementSyntaxNode)
-    DECL_FIELD(StatementSyntaxNode*, parentStmt RAW(= nullptr))
+ABSTRACT_SYNTAX_CLASS(ChildStmt, Stmt)
+    DECL_FIELD(Stmt*, parentStmt RAW(= nullptr))
 END_SYNTAX_CLASS()
 
 // a `case` or `default` statement inside a `switch`
@@ -63,7 +63,7 @@ END_SYNTAX_CLASS()
 
 // a `case` statement inside a `switch`
 SYNTAX_CLASS(CaseStmt, CaseStmtBase)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, expr)
+    SYNTAX_FIELD(RefPtr<Expr>, expr)
 END_SYNTAX_CLASS()
 
 // a `default` statement inside a `switch`
@@ -74,34 +74,34 @@ ABSTRACT_SYNTAX_CLASS(LoopStmt, BreakableStmt)
 END_SYNTAX_CLASS()
 
 // A `for` statement
-SYNTAX_CLASS(ForStatementSyntaxNode, LoopStmt)
-    SYNTAX_FIELD(RefPtr<StatementSyntaxNode>, InitialStatement)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, SideEffectExpression)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, PredicateExpression)
-    SYNTAX_FIELD(RefPtr<StatementSyntaxNode>, Statement)
+SYNTAX_CLASS(ForStmt, LoopStmt)
+    SYNTAX_FIELD(RefPtr<Stmt>, InitialStatement)
+    SYNTAX_FIELD(RefPtr<Expr>, SideEffectExpression)
+    SYNTAX_FIELD(RefPtr<Expr>, PredicateExpression)
+    SYNTAX_FIELD(RefPtr<Stmt>, Statement)
 END_SYNTAX_CLASS()
 
 // A `for` statement in a language that doesn't restrict the scope
 // of the loop variable to the body.
-SYNTAX_CLASS(UnscopedForStmt, ForStatementSyntaxNode);
+SYNTAX_CLASS(UnscopedForStmt, ForStmt);
 END_SYNTAX_CLASS()
 
-SYNTAX_CLASS(WhileStatementSyntaxNode, LoopStmt)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, Predicate)
-    SYNTAX_FIELD(RefPtr<StatementSyntaxNode>, Statement)
+SYNTAX_CLASS(WhileStmt, LoopStmt)
+    SYNTAX_FIELD(RefPtr<Expr>, Predicate)
+    SYNTAX_FIELD(RefPtr<Stmt>, Statement)
 END_SYNTAX_CLASS()
 
-SYNTAX_CLASS(DoWhileStatementSyntaxNode, LoopStmt)
-    SYNTAX_FIELD(RefPtr<StatementSyntaxNode>, Statement)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, Predicate)
+SYNTAX_CLASS(DoWhileStmt, LoopStmt)
+    SYNTAX_FIELD(RefPtr<Stmt>, Statement)
+    SYNTAX_FIELD(RefPtr<Expr>, Predicate)
 END_SYNTAX_CLASS()
 
 // A compile-time, range-based `for` loop, which will not appear in the output code
 SYNTAX_CLASS(CompileTimeForStmt, ScopeStmt)
     SYNTAX_FIELD(RefPtr<Variable>, varDecl)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, rangeBeginExpr)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, rangeEndExpr)
-    SYNTAX_FIELD(RefPtr<StatementSyntaxNode>, body)
+    SYNTAX_FIELD(RefPtr<Expr>, rangeBeginExpr)
+    SYNTAX_FIELD(RefPtr<Expr>, rangeEndExpr)
+    SYNTAX_FIELD(RefPtr<Stmt>, body)
     SYNTAX_FIELD(RefPtr<IntVal>, rangeBeginVal)
     SYNTAX_FIELD(RefPtr<IntVal>, rangeEndVal)
 END_SYNTAX_CLASS()
@@ -111,14 +111,14 @@ END_SYNTAX_CLASS()
 ABSTRACT_SYNTAX_CLASS(JumpStmt, ChildStmt)
 END_SYNTAX_CLASS()
 
-SIMPLE_SYNTAX_CLASS(BreakStatementSyntaxNode, JumpStmt)
+SIMPLE_SYNTAX_CLASS(BreakStmt, JumpStmt)
 
-SIMPLE_SYNTAX_CLASS(ContinueStatementSyntaxNode, JumpStmt)
+SIMPLE_SYNTAX_CLASS(ContinueStmt, JumpStmt)
 
-SYNTAX_CLASS(ReturnStatementSyntaxNode, StatementSyntaxNode)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, Expression)
+SYNTAX_CLASS(ReturnStmt, Stmt)
+    SYNTAX_FIELD(RefPtr<Expr>, Expression)
 END_SYNTAX_CLASS()
 
-SYNTAX_CLASS(ExpressionStatementSyntaxNode, StatementSyntaxNode)
-    SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, Expression)
+SYNTAX_CLASS(ExpressionStmt, Stmt)
+    SYNTAX_FIELD(RefPtr<Expr>, Expression)
 END_SYNTAX_CLASS()
diff --git a/source/slang/syntax-base-defs.h b/source/slang/syntax-base-defs.h
index bcb37de09..d76607106 100644
--- a/source/slang/syntax-base-defs.h
+++ b/source/slang/syntax-base-defs.h
@@ -2,7 +2,7 @@
 
 // This file defines the primary base classes for the hierarchy of
 // AST nodes and related objects. For example, this is where the
-// basic `Decl`, `Stmt`, `Expr`, `Type`, etc. definitions come from.
+// basic `Decl`, `Stmt`, `Expr`, `type`, etc. definitions come from.
 
 // Base class for all nodes representing actual syntax
 // (thus having a location in the source code)
@@ -64,7 +64,7 @@ END_SYNTAX_CLASS()
 // "canonical" type. The reprsentation caches a pointer to
 // a canonical type on every type, so we can easily
 // operate on the raw representation when needed.
-ABSTRACT_SYNTAX_CLASS(ExpressionType, Val)
+ABSTRACT_SYNTAX_CLASS(Type, Val)
     RAW(typedef ITypeVisitor Visitor;)
 
     RAW(virtual void accept(IValVisitor* visitor, void* extra) override;)
@@ -77,8 +77,8 @@ public:
 
     virtual String ToString() = 0;
 
-    bool Equals(ExpressionType * type);
-    bool Equals(RefPtr<ExpressionType> type);
+    bool Equals(Type * type);
+    bool Equals(RefPtr<Type> type);
 
     bool IsVectorType() { return As<VectorExpressionType>() != nullptr; }
     bool IsArray() { return As<ArrayExpressionType>() != nullptr; }
@@ -105,16 +105,16 @@ public:
     bool IsSampler() { return As<SamplerStateType>() != nullptr; }
     bool IsStruct();
     bool IsClass();
-    ExpressionType* GetCanonicalType();
+    Type* GetCanonicalType();
 
     virtual RefPtr<Val> SubstituteImpl(Substitutions* subst, int* ioDiff) override;
 
     virtual bool EqualsVal(Val* val) override;
 protected:
-    virtual bool EqualsImpl(ExpressionType * type) = 0;
+    virtual bool EqualsImpl(Type * type) = 0;
 
-    virtual ExpressionType* CreateCanonicalType() = 0;
-    ExpressionType* canonicalType = nullptr;
+    virtual Type* CreateCanonicalType() = 0;
+    Type* canonicalType = nullptr;
 
     Session* session = nullptr;
     )
@@ -234,16 +234,16 @@ ABSTRACT_SYNTAX_CLASS(Decl, DeclBase)
     )
 END_SYNTAX_CLASS()
 
-ABSTRACT_SYNTAX_CLASS(ExpressionSyntaxNode, SyntaxNode)
+ABSTRACT_SYNTAX_CLASS(Expr, SyntaxNode)
     RAW(typedef IExprVisitor Visitor;)
 
-    FIELD(QualType, Type)
+    FIELD(QualType, type)
 
     RAW(virtual void accept(IExprVisitor* visitor, void* extra) = 0;)
 
 END_SYNTAX_CLASS()
 
-ABSTRACT_SYNTAX_CLASS(StatementSyntaxNode, ModifiableSyntaxNode)
+ABSTRACT_SYNTAX_CLASS(Stmt, ModifiableSyntaxNode)
     RAW(typedef IStmtVisitor Visitor;)
 
     RAW(virtual void accept(IStmtVisitor* visitor, void* extra) = 0;)
diff --git a/source/slang/syntax-visitors.h b/source/slang/syntax-visitors.h
index 4ccc7fa0b..f2c080a57 100644
--- a/source/slang/syntax-visitors.h
+++ b/source/slang/syntax-visitors.h
@@ -23,7 +23,7 @@ namespace Slang
     // Needed by import declaration checking.
     //
     // TODO: need a better location to declare this.
-    RefPtr<ProgramSyntaxNode> findOrImportModule(
+    RefPtr<ModuleDecl> findOrImportModule(
         CompileRequest*     request,
         String const&       name,
         CodePosition const& loc);
diff --git a/source/slang/syntax.cpp b/source/slang/syntax.cpp
index e9eeeaadc..33fa5be20 100644
--- a/source/slang/syntax.cpp
+++ b/source/slang/syntax.cpp
@@ -10,7 +10,7 @@ namespace Slang
 {
     // BasicExpressionType
 
-    bool BasicExpressionType::EqualsImpl(ExpressionType * type)
+    bool BasicExpressionType::EqualsImpl(Type * type)
     {
         auto basicType = dynamic_cast<const BasicExpressionType*>(type);
         if (basicType == nullptr)
@@ -18,7 +18,7 @@ namespace Slang
         return basicType->BaseType == BaseType;
     }
 
-    ExpressionType* BasicExpressionType::CreateCanonicalType()
+    Type* BasicExpressionType::CreateCanonicalType()
     {
         // A basic type is already canonical, in our setup
         return this;
@@ -76,19 +76,19 @@ namespace Slang
 
 #include "object-meta-end.h"
 
-void ExpressionType::accept(IValVisitor* visitor, void* extra)
+void Type::accept(IValVisitor* visitor, void* extra)
 {
     accept((ITypeVisitor*)visitor, extra);
 }
 
     // TypeExp
 
-    bool TypeExp::Equals(ExpressionType* other)
+    bool TypeExp::Equals(Type* other)
     {
         return type->Equals(other);
     }
 
-    bool TypeExp::Equals(RefPtr<ExpressionType> other)
+    bool TypeExp::Equals(RefPtr<Type> other)
     {
         return type->Equals(other.Ptr());
     }
@@ -102,29 +102,29 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
 
     //
 
-    bool ExpressionType::Equals(ExpressionType * type)
+    bool Type::Equals(Type * type)
     {
         return GetCanonicalType()->EqualsImpl(type->GetCanonicalType());
     }
 
-    bool ExpressionType::Equals(RefPtr<ExpressionType> type)
+    bool Type::Equals(RefPtr<Type> type)
     {
         return Equals(type.Ptr());
     }
 
-    bool ExpressionType::EqualsVal(Val* val)
+    bool Type::EqualsVal(Val* val)
     {
-        if (auto type = dynamic_cast<ExpressionType*>(val))
-            return const_cast<ExpressionType*>(this)->Equals(type);
+        if (auto type = dynamic_cast<Type*>(val))
+            return const_cast<Type*>(this)->Equals(type);
         return false;
     }
 
-    NamedExpressionType* ExpressionType::AsNamedType()
+    NamedExpressionType* Type::AsNamedType()
     {
         return dynamic_cast<NamedExpressionType*>(this);
     }
 
-    RefPtr<Val> ExpressionType::SubstituteImpl(Substitutions* subst, int* ioDiff)
+    RefPtr<Val> Type::SubstituteImpl(Substitutions* subst, int* ioDiff)
     {
         int diff = 0;
         auto canSubst = GetCanonicalType()->SubstituteImpl(subst, &diff);
@@ -140,10 +140,10 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
     }
 
 
-    ExpressionType* ExpressionType::GetCanonicalType()
+    Type* Type::GetCanonicalType()
     {
         if (!this) return nullptr;
-        ExpressionType* et = const_cast<ExpressionType*>(this);
+        Type* et = const_cast<Type*>(this);
         if (!et->canonicalType)
         {
             // TODO(tfoley): worry about thread safety here?
@@ -153,15 +153,15 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return et->canonicalType;
     }
 
-    bool ExpressionType::IsTextureOrSampler()
+    bool Type::IsTextureOrSampler()
     {
         return IsTexture() || IsSampler();
     }
-    bool ExpressionType::IsStruct()
+    bool Type::IsStruct()
     {
         auto declRefType = AsDeclRefType();
         if (!declRefType) return false;
-        auto structDeclRef = declRefType->declRef.As<StructSyntaxNode>();
+        auto structDeclRef = declRefType->declRef.As<StructDecl>();
         if (!structDeclRef) return false;
         return true;
     }
@@ -178,65 +178,65 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         overloadedType->setSession(this);
     }
 
-    ExpressionType* Session::getBoolType()
+    Type* Session::getBoolType()
     {
         return getBuiltinType(BaseType::Bool);
     }
 
-    ExpressionType* Session::getFloatType()
+    Type* Session::getFloatType()
     {
         return getBuiltinType(BaseType::Float);
     }
 
-    ExpressionType* Session::getDoubleType()
+    Type* Session::getDoubleType()
     {
         return getBuiltinType(BaseType::Double);
     }
 
-    ExpressionType* Session::getIntType()
+    Type* Session::getIntType()
     {
         return getBuiltinType(BaseType::Int);
     }
 
-    ExpressionType* Session::getUIntType()
+    Type* Session::getUIntType()
     {
         return getBuiltinType(BaseType::UInt);
     }
 
-    ExpressionType* Session::getVoidType()
+    Type* Session::getVoidType()
     {
         return getBuiltinType(BaseType::Void);
     }
 
-    ExpressionType* Session::getBuiltinType(BaseType flavor)
+    Type* Session::getBuiltinType(BaseType flavor)
     {
-        return RefPtr<ExpressionType>(builtinTypes[(int)flavor]);
+        return RefPtr<Type>(builtinTypes[(int)flavor]);
     }
 
-    ExpressionType* Session::getInitializerListType()
+    Type* Session::getInitializerListType()
     {
         return initializerListType;
     }
 
-    ExpressionType* Session::getOverloadedType()
+    Type* Session::getOverloadedType()
     {
         return overloadedType;
     }
 
-    ExpressionType* Session::getErrorType()
+    Type* Session::getErrorType()
     {
         return errorType;
     }
 
 
-    bool ArrayExpressionType::EqualsImpl(ExpressionType * type)
+    bool ArrayExpressionType::EqualsImpl(Type * type)
     {
         auto arrType = type->AsArrayType();
         if (!arrType)
             return false;
         return (ArrayLength == arrType->ArrayLength && BaseType->Equals(arrType->BaseType.Ptr()));
     }
-    ExpressionType* ArrayExpressionType::CreateCanonicalType()
+    Type* ArrayExpressionType::CreateCanonicalType()
     {
         auto canonicalElementType = BaseType->GetCanonicalType();
         auto canonicalArrayType = getArrayType(
@@ -272,7 +272,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return (declRef.GetHashCode() * 16777619) ^ (int)(typeid(this).hash_code());
     }
 
-    bool DeclRefType::EqualsImpl(ExpressionType * type)
+    bool DeclRefType::EqualsImpl(Type * type)
     {
         if (auto declRefType = type->AsDeclRefType())
         {
@@ -281,7 +281,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return false;
     }
 
-    ExpressionType* DeclRefType::CreateCanonicalType()
+    Type* DeclRefType::CreateCanonicalType()
     {
         // A declaration reference is already canonical
         return this;
@@ -343,9 +343,9 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return DeclRefType::Create(getSession(), substDeclRef);
     }
 
-    static RefPtr<ExpressionType> ExtractGenericArgType(RefPtr<Val> val)
+    static RefPtr<Type> ExtractGenericArgType(RefPtr<Val> val)
     {
-        auto type = val.As<ExpressionType>();
+        auto type = val.As<Type>();
         SLANG_RELEASE_ASSERT(type.Ptr());
         return type;
     }
@@ -512,12 +512,12 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return "overload group";
     }
 
-    bool OverloadGroupType::EqualsImpl(ExpressionType * /*type*/)
+    bool OverloadGroupType::EqualsImpl(Type * /*type*/)
     {
         return false;
     }
 
-    ExpressionType* OverloadGroupType::CreateCanonicalType()
+    Type* OverloadGroupType::CreateCanonicalType()
     {
         return this;
     }
@@ -534,12 +534,12 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return "initializer list";
     }
 
-    bool InitializerListType::EqualsImpl(ExpressionType * /*type*/)
+    bool InitializerListType::EqualsImpl(Type * /*type*/)
     {
         return false;
     }
 
-    ExpressionType* InitializerListType::CreateCanonicalType()
+    Type* InitializerListType::CreateCanonicalType()
     {
         return this;
     }
@@ -556,14 +556,14 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return "error";
     }
 
-    bool ErrorType::EqualsImpl(ExpressionType* type)
+    bool ErrorType::EqualsImpl(Type* type)
     {
         if (auto errorType = type->As<ErrorType>())
             return true;
         return false;
     }
 
-    ExpressionType* ErrorType::CreateCanonicalType()
+    Type* ErrorType::CreateCanonicalType()
     {
         return  this;
     }
@@ -581,13 +581,13 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return declRef.GetName();
     }
 
-    bool NamedExpressionType::EqualsImpl(ExpressionType * /*type*/)
+    bool NamedExpressionType::EqualsImpl(Type * /*type*/)
     {
         SLANG_UNEXPECTED("unreachable");
         return false;
     }
 
-    ExpressionType* NamedExpressionType::CreateCanonicalType()
+    Type* NamedExpressionType::CreateCanonicalType()
     {
         return GetType(declRef)->GetCanonicalType();
     }
@@ -609,7 +609,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
             return "/* unknown FuncType */";
     }
 
-    bool FuncType::EqualsImpl(ExpressionType * type)
+    bool FuncType::EqualsImpl(Type * type)
     {
         if (auto funcType = type->As<FuncType>())
         {
@@ -618,7 +618,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return false;
     }
 
-    ExpressionType* FuncType::CreateCanonicalType()
+    Type* FuncType::CreateCanonicalType()
     {
         return this;
     }
@@ -637,7 +637,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return sb.ProduceString();
     }
 
-    bool TypeType::EqualsImpl(ExpressionType * t)
+    bool TypeType::EqualsImpl(Type * t)
     {
         if (auto typeType = t->As<TypeType>())
         {
@@ -646,7 +646,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return false;
     }
 
-    ExpressionType* TypeType::CreateCanonicalType()
+    Type* TypeType::CreateCanonicalType()
     {
         auto canType = getTypeType(type->GetCanonicalType());
         session->canonicalTypes.Add(canType);
@@ -667,7 +667,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return "<DeclRef<GenericDecl>>";
     }
 
-    bool GenericDeclRefType::EqualsImpl(ExpressionType * type)
+    bool GenericDeclRefType::EqualsImpl(Type * type)
     {
         if (auto genericDeclRefType = type->As<GenericDeclRefType>())
         {
@@ -681,7 +681,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return declRef.GetHashCode();
     }
 
-    ExpressionType* GenericDeclRefType::CreateCanonicalType()
+    Type* GenericDeclRefType::CreateCanonicalType()
     {
         return this;
     }
@@ -716,9 +716,9 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return getElementType()->AsBasicType();
     }
 
-    ExpressionType* MatrixExpressionType::getElementType()
+    Type* MatrixExpressionType::getElementType()
     {
-        return this->declRef.substitutions->args[0].As<ExpressionType>().Ptr();
+        return this->declRef.substitutions->args[0].As<Type>().Ptr();
     }
 
     IntVal* MatrixExpressionType::getRowCount()
@@ -840,7 +840,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
 
     // DeclRefBase
 
-    RefPtr<ExpressionType> DeclRefBase::Substitute(RefPtr<ExpressionType> type) const
+    RefPtr<Type> DeclRefBase::Substitute(RefPtr<Type> type) const
     {
         // No substitutions? Easy.
         if (!substitutions)
@@ -849,7 +849,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         // Otherwise we need to recurse on the type structure
         // and apply substitutions where it makes sense
 
-        return type->Substitute(substitutions.Ptr()).As<ExpressionType>();
+        return type->Substitute(substitutions.Ptr()).As<Type>();
     }
 
     DeclRefBase DeclRefBase::Substitute(DeclRefBase declRef) const
@@ -861,7 +861,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
         return declRef.SubstituteImpl(substitutions.Ptr(), &diff);
     }
 
-    RefPtr<ExpressionSyntaxNode> DeclRefBase::Substitute(RefPtr<ExpressionSyntaxNode> expr) const
+    RefPtr<Expr> DeclRefBase::Substitute(RefPtr<Expr> expr) const
     {
         // No substitutions? Easy.
         if (!substitutions)
@@ -1063,9 +1063,9 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
 
     // HLSLPatchType
 
-    ExpressionType* HLSLPatchType::getElementType()
+    Type* HLSLPatchType::getElementType()
     {
-        return this->declRef.substitutions->args[0].As<ExpressionType>().Ptr();
+        return this->declRef.substitutions->args[0].As<Type>().Ptr();
     }
 
     IntVal* HLSLPatchType::getElementCount()
@@ -1076,7 +1076,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
     // Constructors for types
 
     RefPtr<ArrayExpressionType> getArrayType(
-        ExpressionType* elementType,
+        Type* elementType,
         IntVal*         elementCount)
     {
         auto session = elementType->getSession();
@@ -1088,7 +1088,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
     }
 
     RefPtr<ArrayExpressionType> getArrayType(
-        ExpressionType* elementType)
+        Type* elementType)
     {
         auto session = elementType->getSession();
         auto arrayType = new ArrayExpressionType();
@@ -1107,7 +1107,7 @@ void ExpressionType::accept(IValVisitor* visitor, void* extra)
     }
 
     RefPtr<TypeType> getTypeType(
-        ExpressionType* type)
+        Type* type)
     {
         auto session = type->getSession();
         auto typeType = new TypeType(type);
diff --git a/source/slang/syntax.h b/source/slang/syntax.h
index 56b5624b5..059327e6f 100644
--- a/source/slang/syntax.h
+++ b/source/slang/syntax.h
@@ -14,7 +14,7 @@ namespace Slang
     class Session;
     class Substitutions;
     class SyntaxVisitor;
-    class FunctionSyntaxNode;
+    class FuncDecl;
     class Layout;
 
     struct IExprVisitor;
@@ -214,22 +214,22 @@ namespace Slang
 
     struct QualType
     {
-        RefPtr<ExpressionType>	type;
+        RefPtr<Type>	type;
         bool					IsLeftValue;
 
         QualType()
             : IsLeftValue(false)
         {}
 
-        QualType(ExpressionType* type)
+        QualType(Type* type)
             : type(type)
             , IsLeftValue(false)
         {}
 
-        ExpressionType* Ptr() { return type.Ptr(); }
+        Type* Ptr() { return type.Ptr(); }
 
-        operator RefPtr<ExpressionType>() { return type; }
-        RefPtr<ExpressionType> operator->() { return type; }
+        operator RefPtr<Type>() { return type; }
+        RefPtr<Type> operator->() { return type; }
     };
 
     // A reference to a class of syntax node, that can be
@@ -314,12 +314,12 @@ namespace Slang
         {}
 
         // Apply substitutions to a type or ddeclaration
-        RefPtr<ExpressionType> Substitute(RefPtr<ExpressionType> type) const;
+        RefPtr<Type> Substitute(RefPtr<Type> type) const;
 
         DeclRefBase Substitute(DeclRefBase declRef) const;
 
         // Apply substitutions to an expression
-        RefPtr<ExpressionSyntaxNode> Substitute(RefPtr<ExpressionSyntaxNode> expr) const;
+        RefPtr<Expr> Substitute(RefPtr<Expr> expr) const;
 
         // Apply substitutions to this declaration reference
         DeclRefBase SubstituteImpl(Substitutions* subst, int* ioDiff);
@@ -383,11 +383,11 @@ namespace Slang
             return DeclRef<T>((T*) declRef.decl, declRef.substitutions);
         }
 
-        RefPtr<ExpressionType> Substitute(RefPtr<ExpressionType> type) const
+        RefPtr<Type> Substitute(RefPtr<Type> type) const
         {
             return DeclRefBase::Substitute(type);
         }
-        RefPtr<ExpressionSyntaxNode> Substitute(RefPtr<ExpressionSyntaxNode> expr) const
+        RefPtr<Expr> Substitute(RefPtr<Expr> expr) const
         {
             return DeclRefBase::Substitute(expr);
         }
@@ -590,7 +590,7 @@ namespace Slang
     };
 
     //
-    // Type Expressions
+    // type Expressions
     //
 
     // A "type expression" is a term that we expect to resolve to a type during checking.
@@ -602,35 +602,35 @@ namespace Slang
             : exp(other.exp)
             , type(other.type)
         {}
-        explicit TypeExp(RefPtr<ExpressionSyntaxNode> exp)
+        explicit TypeExp(RefPtr<Expr> exp)
             : exp(exp)
         {}
-        TypeExp(RefPtr<ExpressionSyntaxNode> exp, RefPtr<ExpressionType> type)
+        TypeExp(RefPtr<Expr> exp, RefPtr<Type> type)
             : exp(exp)
             , type(type)
         {}
 
-        RefPtr<ExpressionSyntaxNode> exp;
-        RefPtr<ExpressionType> type;
+        RefPtr<Expr> exp;
+        RefPtr<Type> type;
 
-        bool Equals(ExpressionType* other);
+        bool Equals(Type* other);
 #if 0
         {
             return type->Equals(other);
         }
 #endif
-        bool Equals(RefPtr<ExpressionType> other);
+        bool Equals(RefPtr<Type> other);
 #if 0
         {
             return type->Equals(other.Ptr());
         }
 #endif
-        ExpressionType* Ptr() { return type.Ptr(); }
-        operator ExpressionType*()
+        Type* Ptr() { return type.Ptr(); }
+        operator Type*()
         {
             return type;
         }
-        ExpressionType* operator->() { return Ptr(); }
+        Type* operator->() { return Ptr(); }
 
         TypeExp Accept(SyntaxVisitor* visitor);
     };
@@ -656,11 +656,11 @@ namespace Slang
     // Masks to be applied when lookup up declarations
     enum class LookupMask : uint8_t
     {
-        Type = 0x1,
+        type = 0x1,
         Function = 0x2,
         Value = 0x4,
 
-        All = Type | Function | Value,
+        All = type | Function | Value,
     };
 
     // Represents one item found during lookup
@@ -780,297 +780,17 @@ namespace Slang
 
 #include "object-meta-end.h"
 
-    inline RefPtr<ExpressionType> GetSub(DeclRef<GenericTypeConstraintDecl> const& declRef)
+    inline RefPtr<Type> GetSub(DeclRef<GenericTypeConstraintDecl> const& declRef)
     {
         return declRef.Substitute(declRef.getDecl()->sub.Ptr());
     }
 
-    inline RefPtr<ExpressionType> GetSup(DeclRef<GenericTypeConstraintDecl> const& declRef)
+    inline RefPtr<Type> GetSup(DeclRef<GenericTypeConstraintDecl> const& declRef)
     {
         return declRef.Substitute(declRef.getDecl()->sup.Ptr());
     }
 
-    //
-#if 0
-
-    class SyntaxVisitor : public RefObject
-    {
-    protected:
-        DiagnosticSink * sink = nullptr;
-        DiagnosticSink* getSink() { return sink; }
-
-        SourceLanguage sourceLanguage = SourceLanguage::Unknown;
-    public:
-        void setSourceLanguage(SourceLanguage language)
-        {
-            sourceLanguage = language;
-        }
-
-        SyntaxVisitor(DiagnosticSink * sink)
-            : sink(sink)
-        {}
-        virtual ~SyntaxVisitor()
-        {
-        }
-
-        virtual RefPtr<ProgramSyntaxNode> VisitProgram(ProgramSyntaxNode* program)
-        {
-            for (auto & m : program->Members)
-                m = m->Accept(this).As<Decl>();
-            return program;
-        }
-
-        virtual void visitImportDecl(ImportDecl * decl) = 0;
-
-        virtual RefPtr<FunctionSyntaxNode> VisitFunction(FunctionSyntaxNode* func)
-        {
-            func->ReturnType = func->ReturnType.Accept(this);
-            for (auto & member : func->Members)
-                member = member->Accept(this).As<Decl>();
-            if (func->Body)
-                func->Body = func->Body->Accept(this).As<BlockStatementSyntaxNode>();
-            return func;
-        }
-        virtual RefPtr<ScopeDecl> VisitScopeDecl(ScopeDecl* decl)
-        {
-            // By default don't visit children, because they will always
-            // be encountered in the ordinary flow of the corresponding statement.
-            return decl;
-        }
-        virtual RefPtr<StructSyntaxNode> VisitStruct(StructSyntaxNode * s)
-        {
-            for (auto & f : s->Members)
-                f = f->Accept(this).As<Decl>();
-            return s;
-        }
-        virtual RefPtr<ClassSyntaxNode> VisitClass(ClassSyntaxNode * s)
-        {
-            for (auto & f : s->Members)
-                f = f->Accept(this).As<Decl>();
-            return s;
-        }
-        virtual RefPtr<GenericDecl> VisitGenericDecl(GenericDecl * decl)
-        {
-            for (auto & m : decl->Members)
-                m = m->Accept(this).As<Decl>();
-            decl->inner = decl->inner->Accept(this).As<Decl>();
-            return decl;
-        }
-        virtual RefPtr<TypeDefDecl> VisitTypeDefDecl(TypeDefDecl* decl)
-        {
-            decl->Type = decl->Type.Accept(this);
-            return decl;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitDiscardStatement(DiscardStatementSyntaxNode * stmt)
-        {
-            return stmt;
-        }
-        virtual RefPtr<StructField> VisitStructField(StructField * f)
-        {
-            f->Type = f->Type.Accept(this);
-            return f;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitBlockStatement(BlockStatementSyntaxNode* stmt)
-        {
-            for (auto & s : stmt->Statements)
-                s = s->Accept(this).As<StatementSyntaxNode>();
-            return stmt;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitBreakStatement(BreakStatementSyntaxNode* stmt)
-        {
-            return stmt;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitContinueStatement(ContinueStatementSyntaxNode* stmt)
-        {
-            return stmt;
-        }
-
-        virtual RefPtr<StatementSyntaxNode> VisitDoWhileStatement(DoWhileStatementSyntaxNode* stmt)
-        {
-            if (stmt->Predicate)
-                stmt->Predicate = stmt->Predicate->Accept(this).As<ExpressionSyntaxNode>();
-            if (stmt->Statement)
-                stmt->Statement = stmt->Statement->Accept(this).As<StatementSyntaxNode>();
-            return stmt;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitEmptyStatement(EmptyStatementSyntaxNode* stmt)
-        {
-            return stmt;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitForStatement(ForStatementSyntaxNode* stmt)
-        {
-            if (stmt->InitialStatement)
-                stmt->InitialStatement = stmt->InitialStatement->Accept(this).As<StatementSyntaxNode>();
-            if (stmt->PredicateExpression)
-                stmt->PredicateExpression = stmt->PredicateExpression->Accept(this).As<ExpressionSyntaxNode>();
-            if (stmt->SideEffectExpression)
-                stmt->SideEffectExpression = stmt->SideEffectExpression->Accept(this).As<ExpressionSyntaxNode>();
-            if (stmt->Statement)
-                stmt->Statement = stmt->Statement->Accept(this).As<StatementSyntaxNode>();
-            return stmt;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitIfStatement(IfStatementSyntaxNode* stmt)
-        {
-            if (stmt->Predicate)
-                stmt->Predicate = stmt->Predicate->Accept(this).As<ExpressionSyntaxNode>();
-            if (stmt->PositiveStatement)
-                stmt->PositiveStatement = stmt->PositiveStatement->Accept(this).As<StatementSyntaxNode>();
-            if (stmt->NegativeStatement)
-                stmt->NegativeStatement = stmt->NegativeStatement->Accept(this).As<StatementSyntaxNode>();
-            return stmt;
-        }
-        virtual RefPtr<SwitchStmt> VisitSwitchStmt(SwitchStmt* stmt)
-        {
-            if (stmt->condition)
-                stmt->condition = stmt->condition->Accept(this).As<ExpressionSyntaxNode>();
-            if (stmt->body)
-                stmt->body = stmt->body->Accept(this).As<BlockStatementSyntaxNode>();
-            return stmt;
-        }
-        virtual RefPtr<CaseStmt> VisitCaseStmt(CaseStmt* stmt)
-        {
-            if (stmt->expr)
-                stmt->expr = stmt->expr->Accept(this).As<ExpressionSyntaxNode>();
-            return stmt;
-        }
-        virtual RefPtr<DefaultStmt> VisitDefaultStmt(DefaultStmt* stmt)
-        {
-            return stmt;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitReturnStatement(ReturnStatementSyntaxNode* stmt)
-        {
-            if (stmt->Expression)
-                stmt->Expression = stmt->Expression->Accept(this).As<ExpressionSyntaxNode>();
-            return stmt;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitVarDeclrStatement(VarDeclrStatementSyntaxNode* stmt)
-        {
-            stmt->decl = stmt->decl->Accept(this).As<DeclBase>();
-            return stmt;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitWhileStatement(WhileStatementSyntaxNode* stmt)
-        {
-            if (stmt->Predicate)
-                stmt->Predicate = stmt->Predicate->Accept(this).As<ExpressionSyntaxNode>();
-            if (stmt->Statement)
-                stmt->Statement = stmt->Statement->Accept(this).As<StatementSyntaxNode>();
-            return stmt;
-        }
-        virtual RefPtr<StatementSyntaxNode> VisitExpressionStatement(ExpressionStatementSyntaxNode* stmt)
-        {
-            if (stmt->Expression)
-                stmt->Expression = stmt->Expression->Accept(this).As<ExpressionSyntaxNode>();
-            return stmt;
-        }
-
-        virtual RefPtr<ExpressionSyntaxNode> VisitOperatorExpression(OperatorExpressionSyntaxNode* expr)
-        {
-            for (auto && child : expr->Arguments)
-                child->Accept(this);
-            return expr;
-        }
-        virtual RefPtr<ExpressionSyntaxNode> VisitConstantExpression(ConstantExpressionSyntaxNode* expr)
-        {
-            return expr;
-        }
-        virtual RefPtr<ExpressionSyntaxNode> VisitIndexExpression(IndexExpressionSyntaxNode* expr)
-        {
-            if (expr->BaseExpression)
-                expr->BaseExpression = expr->BaseExpression->Accept(this).As<ExpressionSyntaxNode>();
-            if (expr->IndexExpression)
-                expr->IndexExpression = expr->IndexExpression->Accept(this).As<ExpressionSyntaxNode>();
-            return expr;
-        }
-        virtual RefPtr<ExpressionSyntaxNode> VisitMemberExpression(MemberExpressionSyntaxNode * stmt)
-        {
-            if (stmt->BaseExpression)
-                stmt->BaseExpression = stmt->BaseExpression->Accept(this).As<ExpressionSyntaxNode>();
-            return stmt;
-        }
-        virtual RefPtr<ExpressionSyntaxNode> VisitSwizzleExpression(SwizzleExpr * expr)
-        {
-            if (expr->base)
-                expr->base->Accept(this);
-            return expr;
-        }
-        virtual RefPtr<ExpressionSyntaxNode> VisitInvokeExpression(InvokeExpressionSyntaxNode* stmt)
-        {
-            stmt->FunctionExpr->Accept(this);
-            for (auto & arg : stmt->Arguments)
-                arg = arg->Accept(this).As<ExpressionSyntaxNode>();
-            return stmt;
-        }
-        virtual RefPtr<ExpressionSyntaxNode> VisitTypeCastExpression(TypeCastExpressionSyntaxNode * stmt)
-        {
-            if (stmt->Expression)
-                stmt->Expression = stmt->Expression->Accept(this).As<ExpressionSyntaxNode>();
-            return stmt->Expression;
-        }
-        virtual RefPtr<ExpressionSyntaxNode> VisitVarExpression(VarExpressionSyntaxNode* expr)
-        {
-            return expr;
-        }
-
-        virtual RefPtr<ParameterSyntaxNode> VisitParameter(ParameterSyntaxNode* param)
-        {
-            return param;
-        }
-        virtual RefPtr<ExpressionSyntaxNode> VisitGenericApp(GenericAppExpr* type)
-        {
-            return type;
-        }
-
-        virtual RefPtr<Variable> VisitDeclrVariable(Variable* dclr)
-        {
-            if (dclr->Expr)
-                dclr->Expr = dclr->Expr->Accept(this).As<ExpressionSyntaxNode>();
-            return dclr;
-        }
-
-        virtual TypeExp VisitTypeExp(TypeExp const& typeExp)
-        {
-            TypeExp result = typeExp;
-            result.exp = typeExp.exp->Accept(this).As<ExpressionSyntaxNode>();
-            if (auto typeType = result.exp->Type.type.As<TypeType>())
-            {
-                result.type = typeType->type;
-            }
-            return result;
-        }
-
-        virtual void VisitExtensionDecl(ExtensionDecl* /*decl*/)
-        {}
-
-        virtual void VisitConstructorDecl(ConstructorDecl* /*decl*/)
-        {}
-
-        virtual void visitSubscriptDecl(SubscriptDecl* decl) = 0;
-
-        virtual void visitAccessorDecl(AccessorDecl* decl) = 0;
-
-        virtual void visitInterfaceDecl(InterfaceDecl* /*decl*/) = 0;
-
-        virtual void visitInheritanceDecl(InheritanceDecl* /*decl*/) = 0;
-
-        virtual RefPtr<ExpressionSyntaxNode> VisitSharedTypeExpr(SharedTypeExpr* typeExpr)
-        {
-            return typeExpr;
-        }
-
-        virtual void VisitDeclGroup(DeclGroup* declGroup)
-        {
-            for (auto decl : declGroup->decls)
-            {
-                decl->Accept(this);
-            }
-        }
-
-        virtual RefPtr<ExpressionSyntaxNode> visitInitializerListExpr(InitializerListExpr* expr) = 0;
-    };
-
-#endif
-
-    // Note(tfoley): These logically belong to `ExpressionType`,
+    // Note(tfoley): These logically belong to `Type`,
     // but order-of-declaration stuff makes that tricky
     //
     // TODO(tfoley): These should really belong to the compilation context!
@@ -1123,17 +843,17 @@ namespace Slang
         return FilteredMemberRefList<T>(declRef.getDecl()->Members, declRef.substitutions);
     }
 
-    inline RefPtr<ExpressionType> GetType(DeclRef<VarDeclBase> const& declRef)
+    inline RefPtr<Type> GetType(DeclRef<VarDeclBase> const& declRef)
     {
-        return declRef.Substitute(declRef.getDecl()->Type.Ptr());
+        return declRef.Substitute(declRef.getDecl()->type.Ptr());
     }
 
-    inline RefPtr<ExpressionSyntaxNode> getInitExpr(DeclRef<VarDeclBase> const& declRef)
+    inline RefPtr<Expr> getInitExpr(DeclRef<VarDeclBase> const& declRef)
     {
-        return declRef.Substitute(declRef.getDecl()->Expr);
+        return declRef.Substitute(declRef.getDecl()->initExpr);
     }
 
-    inline RefPtr<ExpressionType> GetTargetType(DeclRef<ExtensionDecl> const& declRef)
+    inline RefPtr<Type> GetTargetType(DeclRef<ExtensionDecl> const& declRef)
     {
         return declRef.Substitute(declRef.getDecl()->targetType.Ptr());
     }
@@ -1143,29 +863,29 @@ namespace Slang
         return declRef.getDecl()->candidateExtensions;
     }
 
-    inline FilteredMemberRefList<StructField> GetFields(DeclRef<StructSyntaxNode> const& declRef)
+    inline FilteredMemberRefList<StructField> GetFields(DeclRef<StructDecl> const& declRef)
     {
         return getMembersOfType<StructField>(declRef);
     }
 
-    inline RefPtr<ExpressionType> getBaseType(DeclRef<InheritanceDecl> const& declRef)
+    inline RefPtr<Type> getBaseType(DeclRef<InheritanceDecl> const& declRef)
     {
         return declRef.Substitute(declRef.getDecl()->base.type);
     }
 
-    inline RefPtr<ExpressionType> GetType(DeclRef<TypeDefDecl> const& declRef)
+    inline RefPtr<Type> GetType(DeclRef<TypeDefDecl> const& declRef)
     {
-        return declRef.Substitute(declRef.getDecl()->Type.Ptr());
+        return declRef.Substitute(declRef.getDecl()->type.Ptr());
     }
 
-    inline RefPtr<ExpressionType> GetResultType(DeclRef<CallableDecl> const& declRef)
+    inline RefPtr<Type> GetResultType(DeclRef<CallableDecl> const& declRef)
     {
         return declRef.Substitute(declRef.getDecl()->ReturnType.type.Ptr());
     }
 
-    inline FilteredMemberRefList<ParameterSyntaxNode> GetParameters(DeclRef<CallableDecl> const& declRef)
+    inline FilteredMemberRefList<ParamDecl> GetParameters(DeclRef<CallableDecl> const& declRef)
     {
-        return getMembersOfType<ParameterSyntaxNode>(declRef);
+        return getMembersOfType<ParamDecl>(declRef);
     }
 
     inline Decl* GetInner(DeclRef<GenericDecl> const& declRef)
@@ -1179,18 +899,18 @@ namespace Slang
     //
 
     RefPtr<ArrayExpressionType> getArrayType(
-        ExpressionType* elementType,
+        Type* elementType,
         IntVal*         elementCount);
 
     RefPtr<ArrayExpressionType> getArrayType(
-        ExpressionType* elementType);
+        Type* elementType);
 
     RefPtr<NamedExpressionType> getNamedType(
         Session*                    session,
         DeclRef<TypeDefDecl> const& declRef);
 
     RefPtr<TypeType> getTypeType(
-        ExpressionType* type);
+        Type* type);
 
     RefPtr<FuncType> getFuncType(
         Session*                        session,
diff --git a/source/slang/token.h b/source/slang/token.h
index f177eb512..f29f2b4c6 100644
--- a/source/slang/token.h
+++ b/source/slang/token.h
@@ -26,7 +26,7 @@ typedef unsigned int TokenFlags;
 class Token
 {
 public:
-	TokenType Type = TokenType::Unknown;
+	TokenType type = TokenType::Unknown;
 	String Content;
 	CodePosition Position;
     TokenFlags flags = 0;
@@ -34,7 +34,7 @@ public:
 	Token(TokenType type, const String & content, int line, int col, int pos, String fileName, TokenFlags flags = 0)
         : flags(flags)
 	{
-		Type = type;
+		type = type;
 		Content = content;
 		Position = CodePosition(line, col, pos, fileName);
 	}
diff --git a/source/slang/type-defs.h b/source/slang/type-defs.h
index c1818eae0..d556e58e4 100644
--- a/source/slang/type-defs.h
+++ b/source/slang/type-defs.h
@@ -3,46 +3,46 @@
 // Syntax class definitions for types.
 
 // The type of a reference to an overloaded name
-SYNTAX_CLASS(OverloadGroupType, ExpressionType)
+SYNTAX_CLASS(OverloadGroupType, Type)
 RAW(
 public:
     virtual String ToString() override;
 
 protected:
-    virtual bool EqualsImpl(ExpressionType * type) override;
-    virtual ExpressionType* CreateCanonicalType() override;
+    virtual bool EqualsImpl(Type * type) override;
+    virtual Type* CreateCanonicalType() override;
     virtual int GetHashCode() override;
 )
 END_SYNTAX_CLASS()
 
 // The type of an initializer-list expression (before it has
 // been coerced to some other type)
-SYNTAX_CLASS(InitializerListType, ExpressionType)
+SYNTAX_CLASS(InitializerListType, Type)
 RAW(
     virtual String ToString() override;
 
 protected:
-    virtual bool EqualsImpl(ExpressionType * type) override;
-    virtual ExpressionType* CreateCanonicalType() override;
+    virtual bool EqualsImpl(Type * type) override;
+    virtual Type* CreateCanonicalType() override;
     virtual int GetHashCode() override;
 )
 END_SYNTAX_CLASS()
 
 // The type of an expression that was erroneous
-SYNTAX_CLASS(ErrorType, ExpressionType)
+SYNTAX_CLASS(ErrorType, Type)
 RAW(
 public:
     virtual String ToString() override;
 
 protected:
-    virtual bool EqualsImpl(ExpressionType * type) override;
-    virtual ExpressionType* CreateCanonicalType() override;
+    virtual bool EqualsImpl(Type * type) override;
+    virtual Type* CreateCanonicalType() override;
     virtual int GetHashCode() override;
 )
 END_SYNTAX_CLASS()
 
 // A type that takes the form of a reference to some declaration
-SYNTAX_CLASS(DeclRefType, ExpressionType)
+SYNTAX_CLASS(DeclRefType, Type)
     DECL_FIELD(DeclRef<Decl>, declRef)
 
 RAW(
@@ -61,8 +61,8 @@ RAW(
     {}
 protected:
     virtual int GetHashCode() override;
-    virtual bool EqualsImpl(ExpressionType * type) override;
-    virtual ExpressionType* CreateCanonicalType() override;
+    virtual bool EqualsImpl(Type * type) override;
+    virtual Type* CreateCanonicalType() override;
 )
 END_SYNTAX_CLASS()
 
@@ -88,8 +88,8 @@ RAW(
     virtual Slang::String ToString() override;
 protected:
     virtual BasicExpressionType* GetScalarType() override;
-    virtual bool EqualsImpl(ExpressionType * type) override;
-    virtual ExpressionType* CreateCanonicalType() override;
+    virtual bool EqualsImpl(Type * type) override;
+    virtual Type* CreateCanonicalType() override;
 )
 END_SYNTAX_CLASS()
 
@@ -150,7 +150,7 @@ END_SYNTAX_CLASS()
 // Resources that contain "elements" that can be fetched
 ABSTRACT_SYNTAX_CLASS(ResourceType, ResourceTypeBase)
     // The type that results from fetching an element from this resource
-    SYNTAX_FIELD(RefPtr<ExpressionType>, elementType)
+    SYNTAX_FIELD(RefPtr<Type>, elementType)
 END_SYNTAX_CLASS()
 
 ABSTRACT_SYNTAX_CLASS(TextureTypeBase, ResourceType)
@@ -159,7 +159,7 @@ RAW(
     {}
     TextureTypeBase(
         Flavor flavor,
-        RefPtr<ExpressionType> elementType)
+        RefPtr<Type> elementType)
     {
         this->elementType = elementType;
         this->flavor = flavor;
@@ -173,7 +173,7 @@ RAW(
     {}
     TextureType(
         Flavor flavor,
-        RefPtr<ExpressionType> elementType)
+        RefPtr<Type> elementType)
         : TextureTypeBase(flavor, elementType)
     {}
 )
@@ -187,7 +187,7 @@ RAW(
     {}
     TextureSamplerType(
         Flavor flavor,
-        RefPtr<ExpressionType> elementType)
+        RefPtr<Type> elementType)
         : TextureTypeBase(flavor, elementType)
     {}
 )
@@ -200,7 +200,7 @@ RAW(
     {}
     GLSLImageType(
         Flavor flavor,
-        RefPtr<ExpressionType> elementType)
+        RefPtr<Type> elementType)
         : TextureTypeBase(flavor, elementType)
     {}
 )
@@ -221,7 +221,7 @@ END_SYNTAX_CLASS()
 
 // Other cases of generic types known to the compiler
 SYNTAX_CLASS(BuiltinGenericType, DeclRefType)
-    SYNTAX_FIELD(RefPtr<ExpressionType>, elementType)
+    SYNTAX_FIELD(RefPtr<Type>, elementType)
 END_SYNTAX_CLASS()
 
 // Types that behave like pointers, in that they can be
@@ -243,7 +243,7 @@ SIMPLE_SYNTAX_CLASS(HLSLConsumeStructuredBufferType, BuiltinGenericType)
 
 SYNTAX_CLASS(HLSLPatchType, DeclRefType)
 RAW(
-    ExpressionType* getElementType();
+    Type* getElementType();
     IntVal*         getElementCount();
 )
 END_SYNTAX_CLASS()
@@ -268,30 +268,30 @@ SIMPLE_SYNTAX_CLASS(ParameterBlockType, PointerLikeType)
 SIMPLE_SYNTAX_CLASS(UniformParameterBlockType, ParameterBlockType)
 SIMPLE_SYNTAX_CLASS(VaryingParameterBlockType, ParameterBlockType)
 
-// Type for HLSL `cbuffer` declarations, and `ConstantBuffer<T>`
+// type for HLSL `cbuffer` declarations, and `ConstantBuffer<T>`
 // ALso used for GLSL `uniform` blocks.
 SIMPLE_SYNTAX_CLASS(ConstantBufferType, UniformParameterBlockType)
 
-// Type for HLSL `tbuffer` declarations, and `TextureBuffer<T>`
+// type for HLSL `tbuffer` declarations, and `TextureBuffer<T>`
 SIMPLE_SYNTAX_CLASS(TextureBufferType, UniformParameterBlockType)
 
-// Type for GLSL `in` and `out` blocks
+// type for GLSL `in` and `out` blocks
 SIMPLE_SYNTAX_CLASS(GLSLInputParameterBlockType, VaryingParameterBlockType)
 SIMPLE_SYNTAX_CLASS(GLSLOutputParameterBlockType, VaryingParameterBlockType)
 
-// Type for GLLSL `buffer` blocks
+// type for GLLSL `buffer` blocks
 SIMPLE_SYNTAX_CLASS(GLSLShaderStorageBufferType, UniformParameterBlockType)
 
-SYNTAX_CLASS(ArrayExpressionType, ExpressionType)
-    SYNTAX_FIELD(RefPtr<ExpressionType>, BaseType)
+SYNTAX_CLASS(ArrayExpressionType, Type)
+    SYNTAX_FIELD(RefPtr<Type>, BaseType)
     SYNTAX_FIELD(RefPtr<IntVal>, ArrayLength)
 
 RAW(
     virtual Slang::String ToString() override;
 
 protected:
-    virtual bool EqualsImpl(ExpressionType * type) override;
-    virtual ExpressionType* CreateCanonicalType() override;
+    virtual bool EqualsImpl(Type * type) override;
+    virtual Type* CreateCanonicalType() override;
     virtual int GetHashCode() override;
 )
 END_SYNTAX_CLASS()
@@ -299,23 +299,23 @@ END_SYNTAX_CLASS()
 // The "type" of an expression that resolves to a type.
 // For example, in the expression `float(2)` the sub-expression,
 // `float` would have the type `TypeType(float)`.
-SYNTAX_CLASS(TypeType, ExpressionType)
+SYNTAX_CLASS(TypeType, Type)
     // The type that this is the type of...
-    SYNTAX_FIELD(RefPtr<ExpressionType>, type)
+    SYNTAX_FIELD(RefPtr<Type>, type)
 
 RAW(
 public:
     TypeType()
     {}
-    TypeType(RefPtr<ExpressionType> type)
+    TypeType(RefPtr<Type> type)
         : type(type)
     {}
 
     virtual String ToString() override;
 
 protected:
-    virtual bool EqualsImpl(ExpressionType * type) override;
-    virtual ExpressionType* CreateCanonicalType() override;
+    virtual bool EqualsImpl(Type * type) override;
+    virtual Type* CreateCanonicalType() override;
     virtual int GetHashCode() override;
 )
 END_SYNTAX_CLASS()
@@ -325,7 +325,7 @@ SYNTAX_CLASS(VectorExpressionType, ArithmeticExpressionType)
 
     // The type of vector elements.
     // As an invariant, this should be a basic type or an alias.
-    SYNTAX_FIELD(RefPtr<ExpressionType>, elementType)
+    SYNTAX_FIELD(RefPtr<Type>, elementType)
 
     // The number of elements
     SYNTAX_FIELD(RefPtr<IntVal>, elementCount)
@@ -342,7 +342,7 @@ END_SYNTAX_CLASS()
 SYNTAX_CLASS(MatrixExpressionType, ArithmeticExpressionType)
 RAW(
 
-    ExpressionType* getElementType();
+    Type* getElementType();
     IntVal*         getRowCount();
     IntVal*         getColumnCount();
 
@@ -355,7 +355,7 @@ protected:
 END_SYNTAX_CLASS()
 
 // A type alias of some kind (e.g., via `typedef`)
-SYNTAX_CLASS(NamedExpressionType, ExpressionType)
+SYNTAX_CLASS(NamedExpressionType, Type)
     DECL_FIELD(DeclRef<TypeDefDecl>, declRef)
 
 RAW(
@@ -370,8 +370,8 @@ RAW(
     virtual String ToString() override;
 
 protected:
-    virtual bool EqualsImpl(ExpressionType * type) override;
-    virtual ExpressionType* CreateCanonicalType() override;
+    virtual bool EqualsImpl(Type * type) override;
+    virtual Type* CreateCanonicalType() override;
     virtual int GetHashCode() override;
 )
 END_SYNTAX_CLASS()
@@ -380,7 +380,7 @@ END_SYNTAX_CLASS()
 // either ordinary functions, or "component functions."
 // We do not directly store a representation of the type, and instead
 // use a reference to the symbol to stand in for its logical type
-SYNTAX_CLASS(FuncType, ExpressionType)
+SYNTAX_CLASS(FuncType, Type)
     DECL_FIELD(DeclRef<CallableDecl>, declRef)
 
 RAW(
@@ -389,14 +389,14 @@ RAW(
 
     virtual String ToString() override;
 protected:
-    virtual bool EqualsImpl(ExpressionType * type) override;
-    virtual ExpressionType* CreateCanonicalType() override;
+    virtual bool EqualsImpl(Type * type) override;
+    virtual Type* CreateCanonicalType() override;
     virtual int GetHashCode() override;
 )
 END_SYNTAX_CLASS()
 
 // The "type" of an expression that names a generic declaration.
-SYNTAX_CLASS(GenericDeclRefType, ExpressionType)
+SYNTAX_CLASS(GenericDeclRefType, Type)
 
     DECL_FIELD(DeclRef<GenericDecl>, declRef)
 
@@ -414,9 +414,9 @@ SYNTAX_CLASS(GenericDeclRefType, ExpressionType)
     virtual String ToString() override;
 
 protected:
-    virtual bool EqualsImpl(ExpressionType * type) override;
+    virtual bool EqualsImpl(Type * type) override;
     virtual int GetHashCode() override;
-    virtual ExpressionType* CreateCanonicalType() override;
+    virtual Type* CreateCanonicalType() override;
 )
 END_SYNTAX_CLASS()
 
diff --git a/source/slang/type-layout.cpp b/source/slang/type-layout.cpp
index 245993881..544071b84 100644
--- a/source/slang/type-layout.cpp
+++ b/source/slang/type-layout.cpp
@@ -624,7 +624,7 @@ bool IsResourceKind(LayoutResourceKind kind)
 
 SimpleLayoutInfo GetSimpleLayoutImpl(
     SimpleLayoutInfo        info,
-    RefPtr<ExpressionType>  type,
+    RefPtr<Type>  type,
     LayoutRulesImpl*        rules,
     RefPtr<TypeLayout>*     outTypeLayout)
 {
@@ -740,7 +740,7 @@ RefPtr<ParameterBlockTypeLayout>
 createParameterBlockTypeLayout(
     RefPtr<ParameterBlockType>  parameterBlockType,
     LayoutRulesImpl*            parameterBlockRules,
-    RefPtr<ExpressionType>      elementType,
+    RefPtr<Type>      elementType,
     LayoutRulesImpl*            elementTypeRules)
 {
     // First compute resource usage of the block itself.
@@ -832,7 +832,7 @@ createParameterBlockTypeLayout(
 RefPtr<StructuredBufferTypeLayout>
 createStructuredBufferTypeLayout(
     ShaderParameterKind     kind,
-    RefPtr<ExpressionType>  structuredBufferType,
+    RefPtr<Type>  structuredBufferType,
     RefPtr<TypeLayout>      elementTypeLayout,
     LayoutRulesImpl*        rules)
 {
@@ -865,8 +865,8 @@ createStructuredBufferTypeLayout(
 RefPtr<StructuredBufferTypeLayout>
 createStructuredBufferTypeLayout(
     ShaderParameterKind     kind,
-    RefPtr<ExpressionType>  structuredBufferType,
-    RefPtr<ExpressionType>  elementType,
+    RefPtr<Type>  structuredBufferType,
+    RefPtr<Type>  elementType,
     LayoutRulesImpl*        rules)
 {
     // TODO(tfoley): need to compute the layout for the constant
@@ -888,13 +888,13 @@ createStructuredBufferTypeLayout(
 }
 
 SimpleLayoutInfo GetLayoutImpl(
-    ExpressionType*     type,
+    Type*     type,
     LayoutRulesImpl*    rules,
     RefPtr<TypeLayout>* outTypeLayout,
     SimpleLayoutInfo    offset);
 
 SimpleLayoutInfo GetLayoutImpl(
-    ExpressionType*     type,
+    Type*     type,
     LayoutRulesImpl*    rules,
     RefPtr<TypeLayout>* outTypeLayout)
 {
@@ -902,7 +902,7 @@ SimpleLayoutInfo GetLayoutImpl(
 }
 
 SimpleLayoutInfo GetLayoutImpl(
-    ExpressionType*     type,
+    Type*     type,
     LayoutRulesImpl*    rules,
     RefPtr<TypeLayout>* outTypeLayout,
     SimpleLayoutInfo    offset)
@@ -1154,7 +1154,7 @@ SimpleLayoutInfo GetLayoutImpl(
     {
         auto declRef = declRefType->declRef;
 
-        if (auto structDeclRef = declRef.As<StructSyntaxNode>())
+        if (auto structDeclRef = declRef.As<StructDecl>())
         {
             RefPtr<StructTypeLayout> typeLayout;
             if (outTypeLayout)
@@ -1270,24 +1270,24 @@ SimpleLayoutInfo GetLayoutImpl(
         outTypeLayout);
 }
 
-SimpleLayoutInfo GetLayout(ExpressionType* inType, LayoutRulesImpl* rules)
+SimpleLayoutInfo GetLayout(Type* inType, LayoutRulesImpl* rules)
 {
     return GetLayoutImpl(inType, rules, nullptr);
 }
 
-RefPtr<TypeLayout> CreateTypeLayout(ExpressionType* type, LayoutRulesImpl* rules, SimpleLayoutInfo offset)
+RefPtr<TypeLayout> CreateTypeLayout(Type* type, LayoutRulesImpl* rules, SimpleLayoutInfo offset)
 {
     RefPtr<TypeLayout> typeLayout;
     GetLayoutImpl(type, rules, &typeLayout, offset);
     return typeLayout;
 }
 
-RefPtr<TypeLayout> CreateTypeLayout(ExpressionType* type, LayoutRulesImpl* rules)
+RefPtr<TypeLayout> CreateTypeLayout(Type* type, LayoutRulesImpl* rules)
 {
     return CreateTypeLayout(type, rules, SimpleLayoutInfo());
 }
 
-SimpleLayoutInfo GetLayout(ExpressionType* type, LayoutRule rule)
+SimpleLayoutInfo GetLayout(Type* type, LayoutRule rule)
 {
     LayoutRulesImpl* rulesImpl = GetLayoutRulesImpl(rule);
     return GetLayout(type, rulesImpl);
diff --git a/source/slang/type-layout.h b/source/slang/type-layout.h
index 7be1c595f..7d037b2e7 100644
--- a/source/slang/type-layout.h
+++ b/source/slang/type-layout.h
@@ -16,7 +16,7 @@ typedef uintptr_t UInt;
 // Forward declarations
 
 enum class BaseType;
-class ExpressionType;
+class Type;
 
 //
 
@@ -154,8 +154,8 @@ class TypeLayout : public Layout
 {
 public:
     // The type that was laid out
-    RefPtr<ExpressionType>  type;
-    ExpressionType* getType() { return type.Ptr(); }
+    RefPtr<Type>  type;
+    Type* getType() { return type.Ptr(); }
 
     // The layout rules that were used to produce this type
     LayoutRulesImpl*        rules;
@@ -287,14 +287,14 @@ public:
     }
 };
 
-// Type layout for a variable that has a constant-buffer type
+// type layout for a variable that has a constant-buffer type
 class ParameterBlockTypeLayout : public TypeLayout
 {
 public:
     RefPtr<TypeLayout> elementTypeLayout;
 };
 
-// Type layout for a variable that has a constant-buffer type
+// type layout for a variable that has a constant-buffer type
 class StructuredBufferTypeLayout : public TypeLayout
 {
 public:
@@ -345,7 +345,7 @@ class EntryPointLayout : public StructTypeLayout
 {
 public:
     // The corresponding function declaration
-    RefPtr<FunctionSyntaxNode> entryPoint;
+    RefPtr<FuncDecl> entryPoint;
 
     // The shader profile that was used to compile the entry point
     Profile profile;
@@ -532,12 +532,12 @@ LayoutRulesImpl* GetLayoutRulesImpl(LayoutRule rule);
 LayoutRulesFamilyImpl* GetLayoutRulesFamilyImpl(LayoutRulesFamily rule);
 LayoutRulesFamilyImpl* GetLayoutRulesFamilyImpl(CodeGenTarget target);
 
-SimpleLayoutInfo GetLayout(ExpressionType* type, LayoutRulesImpl* rules);
+SimpleLayoutInfo GetLayout(Type* type, LayoutRulesImpl* rules);
 
-SimpleLayoutInfo GetLayout(ExpressionType* type, LayoutRule rule = LayoutRule::Std430);
+SimpleLayoutInfo GetLayout(Type* type, LayoutRule rule = LayoutRule::Std430);
 
-RefPtr<TypeLayout> CreateTypeLayout(ExpressionType* type, LayoutRulesImpl* rules);
-RefPtr<TypeLayout> CreateTypeLayout(ExpressionType* type, LayoutRulesImpl* rules, SimpleLayoutInfo offset);
+RefPtr<TypeLayout> CreateTypeLayout(Type* type, LayoutRulesImpl* rules);
+RefPtr<TypeLayout> CreateTypeLayout(Type* type, LayoutRulesImpl* rules, SimpleLayoutInfo offset);
 
 //
 
@@ -551,7 +551,7 @@ RefPtr<ParameterBlockTypeLayout>
 createParameterBlockTypeLayout(
     RefPtr<ParameterBlockType>  parameterBlockType,
     LayoutRulesImpl*            parameterBlockRules,
-    RefPtr<ExpressionType>      elementType,
+    RefPtr<Type>      elementType,
     LayoutRulesImpl*            elementTypeRules);
 
 RefPtr<ParameterBlockTypeLayout>
@@ -565,8 +565,8 @@ createParameterBlockTypeLayout(
 RefPtr<StructuredBufferTypeLayout>
 createStructuredBufferTypeLayout(
     ShaderParameterKind     kind,
-    RefPtr<ExpressionType>  structuredBufferType,
-    RefPtr<ExpressionType>  elementType,
+    RefPtr<Type>  structuredBufferType,
+    RefPtr<Type>  elementType,
     LayoutRulesImpl*        rules);
 
 
diff --git a/source/slang/visitor.h b/source/slang/visitor.h
index 7000927c7..59c5772f2 100644
--- a/source/slang/visitor.h
+++ b/source/slang/visitor.h
@@ -10,7 +10,7 @@
 namespace Slang {
 
 //
-// Type Visitors
+// type Visitors
 //
 
 struct ITypeVisitor
@@ -27,7 +27,7 @@ struct ITypeVisitor
 template<typename Derived, typename Result = void, typename Base = ITypeVisitor>
 struct TypeVisitor : Base
 {
-    Result dispatch(ExpressionType* type)
+    Result dispatch(Type* type)
     {
         Result result;
         type->accept(this, &result);
@@ -56,7 +56,7 @@ struct TypeVisitor : Base
 template<typename Derived, typename Base>
 struct TypeVisitor<Derived,void,Base> : Base
 {
-    void dispatch(ExpressionType* type)
+    void dispatch(Type* type)
     {
         type->accept(this, 0);
     }
@@ -83,7 +83,7 @@ struct TypeVisitor<Derived,void,Base> : Base
 template<typename Derived, typename Arg, typename Base = ITypeVisitor>
 struct TypeVisitorWithArg : Base
 {
-    void dispatch(ExpressionType* type, Arg const& arg)
+    void dispatch(Type* type, Arg const& arg)
     {
         type->accept(this, (void*)&arg);
     }
@@ -125,7 +125,7 @@ struct IExprVisitor
 template<typename Derived, typename Result = void>
 struct ExprVisitor : IExprVisitor
 {
-    Result dispatch(ExpressionSyntaxNode* expr)
+    Result dispatch(Expr* expr)
     {
         Result result;
         expr->accept(this, &result);
@@ -154,7 +154,7 @@ struct ExprVisitor : IExprVisitor
 template<typename Derived>
 struct ExprVisitor<Derived,void> : IExprVisitor
 {
-    void dispatch(ExpressionSyntaxNode* expr)
+    void dispatch(Expr* expr)
     {
         expr->accept(this, 0);
     }
@@ -181,7 +181,7 @@ struct ExprVisitor<Derived,void> : IExprVisitor
 template<typename Derived, typename Arg>
 struct ExprVisitorWithArg : IExprVisitor
 {
-    void dispatch(ExpressionSyntaxNode* obj, Arg const& arg)
+    void dispatch(Expr* obj, Arg const& arg)
     {
         obj->accept(this, (void*)&arg);
     }
@@ -223,7 +223,7 @@ struct IStmtVisitor
 template<typename Derived, typename Result = void>
 struct StmtVisitor : IStmtVisitor
 {
-    Result dispatch(StatementSyntaxNode* stmt)
+    Result dispatch(Stmt* stmt)
     {
         Result result;
         stmt->accept(this, &result);
@@ -252,7 +252,7 @@ struct StmtVisitor : IStmtVisitor
 template<typename Derived>
 struct StmtVisitor<Derived,void> : IStmtVisitor
 {
-    void dispatch(StatementSyntaxNode* stmt)
+    void dispatch(Stmt* stmt)
     {
         stmt->accept(this, 0);
     }