Initial import of code.

1 files changed, 2537 insertions, 0 deletions

diff --git a/source/slang/emit.cpp b/source/slang/emit.cpp
new file mode 100644
index 000000000..6b488a68f
--- /dev/null
+++ b/source/slang/emit.cpp
@@ -0,0 +1,2537 @@
+// emit.cpp
+#include "emit.h"
+
+#include "syntax.h"
+#include "type-layout.h"
+
+#include <assert.h>
+
+#ifdef _WIN32
+#include <d3dcompiler.h>
+#pragma warning(disable:4996)
+#endif
+
+namespace Slang { namespace Compiler {
+
+struct EmitContext
+{
+    StringBuilder sb;
+
+    // Current source position for tracking purposes...
+    CodePosition loc;
+
+    // The target language we want to generate code for
+    CodeGenTarget target;
+
+    // A set of words reserved by the target
+    Dictionary<String, String> reservedWords;
+};
+
+//
+
+static void EmitDecl(EmitContext* context, RefPtr<Decl> decl);
+static void EmitDecl(EmitContext* context, RefPtr<DeclBase> declBase);
+static void EmitDeclUsingLayout(EmitContext* context, RefPtr<Decl> decl, RefPtr<VarLayout> layout);
+static void EmitType(EmitContext* context, RefPtr<ExpressionType> type, String const& name);
+static void EmitType(EmitContext* context, RefPtr<ExpressionType> type);
+static void EmitExpr(EmitContext* context, RefPtr<ExpressionSyntaxNode> expr);
+static void EmitStmt(EmitContext* context, RefPtr<StatementSyntaxNode> stmt);
+static void EmitDeclRef(EmitContext* context, DeclRef declRef);
+
+// Low-level emit logic
+
+static void emitRawTextSpan(EmitContext* context, char const* textBegin, char const* textEnd)
+{
+    // TODO(tfoley): Need to make "corelib" not use `int` for pointer-sized things...
+    auto len = int(textEnd - textBegin);
+
+    context->sb.Append(textBegin, len);
+}
+
+static void emitRawText(EmitContext* context, char const* text)
+{
+    emitRawTextSpan(context, text, text + strlen(text));
+}
+
+static void emitTextSpan(EmitContext* context, char const* textBegin, char const* textEnd)
+{
+    // Emit the raw text
+    emitRawTextSpan(context, textBegin, textEnd);
+
+    // Update our logical position
+    // TODO(tfoley): Need to make "corelib" not use `int` for pointer-sized things...
+    auto len = int(textEnd - textBegin);
+    context->loc.Col += len;
+}
+
+static void Emit(EmitContext* context, char const* textBegin, char const* textEnd)
+{
+    char const* spanBegin = textBegin;
+
+    char const* spanEnd = spanBegin;
+    for(;;)
+    {
+        if(spanEnd == textEnd)
+        {
+            // We have a whole range of text waiting to be flushed
+            emitTextSpan(context, spanBegin, spanEnd);
+            return;
+        }
+
+        auto c = *spanEnd++;
+
+        if( c == '\n' )
+        {
+            // At the end of a line, we need to update our tracking
+            // information on code positions
+            emitTextSpan(context, spanBegin, spanEnd);
+            context->loc.Line++;
+            context->loc.Col = 1;
+
+            // Start a new span for emit purposes
+            spanBegin = spanEnd;
+        }
+    }
+}
+
+static void Emit(EmitContext* context, char const* text)
+{
+    Emit(context, text, text + strlen(text));
+}
+
+static void emit(EmitContext* context, String const& text)
+{
+    Emit(context, text.begin(), text.end());
+}
+
+static bool isReservedWord(EmitContext* context, String const& name)
+{
+    return context->reservedWords.TryGetValue(name) != nullptr;
+}
+
+static void emitName(EmitContext* context, String const& inName)
+{
+    String name = inName;
+
+    // By default, we would like to emit a name in the generated
+    // code exactly as it appeared in the soriginal program.
+    // When that isn't possible, we'd like to emit a name as
+    // close to the original as possible (to ensure that existing
+    // debugging tools still work reasonably well).
+    //
+    // One reason why a name might not be allowed as-is is that
+    // it could collide with a reserved word in the target language.
+    // Another reason is that it might not follow a naming convention
+    // imposed by the target (e.g., in GLSL names starting with
+    // `gl_` or containing `__` are reserved).
+    //
+    // Given a name that should not be allowed, we want to
+    // change it to a name that *is* allowed. e.g., by adding
+    // `_` to the end of a reserved word.
+    //
+    // The next problem this creates is that the modified name
+    // could not collide with an existing use of the same
+    // (valid) name.
+    //
+    // For now we are going to solve this problem in a simple
+    // and ad hoc fashion, but longer term we'll want to do
+    // something sytematic.
+
+    if (isReservedWord(context, name))
+    {
+        name = name + "_";
+    }
+
+    emit(context, name);
+}
+
+static void Emit(EmitContext* context, UInt value)
+{
+    char buffer[32];
+    sprintf(buffer, "%llu", (unsigned long long)(value));
+    Emit(context, buffer);
+}
+
+static void Emit(EmitContext* context, int value)
+{
+    char buffer[16];
+    sprintf(buffer, "%d", value);
+    Emit(context, buffer);
+}
+
+static void Emit(EmitContext* context, double value)
+{
+    // TODO(tfoley): need to print things in a way that can round-trip
+    char buffer[128];
+    sprintf(buffer, "%.20ff", value);
+    Emit(context, buffer);
+}
+
+// Expressions
+
+// Determine if an expression should not be emitted when it is the base of
+// a member reference expression.
+static bool IsBaseExpressionImplicit(EmitContext* /*context*/, RefPtr<ExpressionSyntaxNode> 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;
+    while (auto derefExpr = e.As<DerefExpr>())
+    {
+        e = derefExpr->base;
+    }
+    // Is the expression referencing a constant buffer?
+    if (auto cbufferType = e->Type->As<ConstantBufferType>())
+    {
+        return true;
+    }
+
+    return false;
+}
+
+enum
+{
+    kPrecedence_None,
+    kPrecedence_Comma,
+
+    kPrecedence_Assign,
+    kPrecedence_AddAssign = kPrecedence_Assign,
+    kPrecedence_SubAssign = kPrecedence_Assign,
+    kPrecedence_MulAssign = kPrecedence_Assign,
+    kPrecedence_DivAssign = kPrecedence_Assign,
+    kPrecedence_ModAssign = kPrecedence_Assign,
+    kPrecedence_LshAssign = kPrecedence_Assign,
+    kPrecedence_RshAssign = kPrecedence_Assign,
+    kPrecedence_OrAssign = kPrecedence_Assign,
+    kPrecedence_AndAssign = kPrecedence_Assign,
+    kPrecedence_XorAssign = kPrecedence_Assign,
+
+    kPrecedence_General = kPrecedence_Assign,
+
+    kPrecedence_Conditional, // "ternary"
+    kPrecedence_Or,
+    kPrecedence_And,
+    kPrecedence_BitOr,
+    kPrecedence_BitXor,
+    kPrecedence_BitAnd,
+
+    kPrecedence_Eql,
+    kPrecedence_Neq = kPrecedence_Eql,
+
+    kPrecedence_Less,
+    kPrecedence_Greater = kPrecedence_Less,
+    kPrecedence_Leq = kPrecedence_Less,
+    kPrecedence_Geq = kPrecedence_Less,
+
+    kPrecedence_Lsh,
+    kPrecedence_Rsh = kPrecedence_Lsh,
+
+    kPrecedence_Add,
+    kPrecedence_Sub = kPrecedence_Add,
+
+    kPrecedence_Mul,
+    kPrecedence_Div = kPrecedence_Mul,
+    kPrecedence_Mod = kPrecedence_Mul,
+
+    kPrecedence_Prefix,
+    kPrecedence_Postfix,
+    kPrecedence_Atomic = kPrecedence_Postfix
+};
+
+static void EmitExprWithPrecedence(EmitContext* context, RefPtr<ExpressionSyntaxNode> expr, int outerPrec);
+
+static void EmitPostfixExpr(EmitContext* context, RefPtr<ExpressionSyntaxNode> expr)
+{
+    EmitExprWithPrecedence(context, expr, kPrecedence_Postfix);
+}
+
+static void EmitExpr(EmitContext* context, RefPtr<ExpressionSyntaxNode> expr)
+{
+    EmitExprWithPrecedence(context, expr, kPrecedence_General);
+}
+
+static bool MaybeEmitParens(EmitContext* context, int outerPrec, int prec)
+{
+    if (prec <= outerPrec)
+    {
+        Emit(context, "(");
+        return true;
+    }
+    return false;
+}
+
+// When we are going to emit an expression in an l-value context,
+// 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
+static RefPtr<ExpressionSyntaxNode> prepareLValueExpr(
+    EmitContext*                    context,
+    RefPtr<ExpressionSyntaxNode>    expr)
+{
+    for(;;)
+    {
+        if(auto typeCastExpr = expr.As<TypeCastExpressionSyntaxNode>())
+        {
+            expr = typeCastExpr->Expression;
+        }
+        // TODO: any other cases?
+        else
+        {
+            return expr;
+        }
+    }
+
+}
+
+static void emitInfixExprImpl(
+    EmitContext* context,
+    int outerPrec,
+    int prec,
+    char const* op,
+    RefPtr<InvokeExpressionSyntaxNode> binExpr,
+    bool isAssign)
+{
+    bool needsClose = MaybeEmitParens(context, outerPrec, prec);
+
+    auto left = binExpr->Arguments[0];
+    if(isAssign)
+    {
+        left = prepareLValueExpr(context, left);
+    }
+
+    EmitExprWithPrecedence(context, left, prec);
+    Emit(context, " ");
+    Emit(context, op);
+    Emit(context, " ");
+    EmitExprWithPrecedence(context, binExpr->Arguments[1], prec);
+    if (needsClose)
+    {
+        Emit(context, ")");
+    }
+}
+
+static void EmitBinExpr(EmitContext* context, int outerPrec, int prec, char const* op, RefPtr<InvokeExpressionSyntaxNode> binExpr)
+{
+    emitInfixExprImpl(context, outerPrec, prec, op, binExpr, false);
+}
+
+static void EmitBinAssignExpr(EmitContext* context, int outerPrec, int prec, char const* op, RefPtr<InvokeExpressionSyntaxNode> binExpr)
+{
+    emitInfixExprImpl(context, outerPrec, prec, op, binExpr, true);
+}
+
+static void emitUnaryExprImpl(
+    EmitContext* context,
+    int outerPrec,
+    int prec,
+    char const* preOp,
+    char const* postOp,
+    RefPtr<InvokeExpressionSyntaxNode> expr,
+    bool isAssign)
+{
+    bool needsClose = MaybeEmitParens(context, outerPrec, prec);
+    Emit(context, preOp);
+
+    auto arg = expr->Arguments[0];
+    if(isAssign)
+    {
+        arg = prepareLValueExpr(context, arg);
+    }
+
+    EmitExprWithPrecedence(context, arg, prec);
+    Emit(context, postOp);
+    if (needsClose)
+    {
+        Emit(context, ")");
+    }
+}
+
+static void EmitUnaryExpr(
+    EmitContext* context,
+    int outerPrec,
+    int prec,
+    char const* preOp,
+    char const* postOp,
+    RefPtr<InvokeExpressionSyntaxNode> expr)
+{
+    emitUnaryExprImpl(context, outerPrec, prec, preOp, postOp, expr, false);
+}
+
+static void EmitUnaryAssignExpr(
+    EmitContext* context,
+    int outerPrec,
+    int prec,
+    char const* preOp,
+    char const* postOp,
+    RefPtr<InvokeExpressionSyntaxNode> expr)
+{
+    emitUnaryExprImpl(context, outerPrec, prec, preOp, postOp, expr, true);
+}
+
+static void emitCallExpr(
+    EmitContext*                        context,
+    RefPtr<InvokeExpressionSyntaxNode>  callExpr,
+    int                                 outerPrec)
+{
+    auto funcExpr = callExpr->FunctionExpr;
+    if (auto funcDeclRefExpr = funcExpr.As<DeclRefExpr>())
+    {
+        auto funcDeclRef = funcDeclRefExpr->declRef;
+        auto funcDecl = funcDeclRef.GetDecl();
+        if (auto intrinsicModifier = funcDecl->FindModifier<IntrinsicModifier>())
+        {
+            switch (intrinsicModifier->op)
+            {
+#define CASE(NAME, OP) case IntrinsicOp::NAME: EmitBinExpr(context, outerPrec, kPrecedence_##NAME, #OP, callExpr); return
+            CASE(Mul, *);
+            CASE(Div, / );
+            CASE(Mod, %);
+            CASE(Add, +);
+            CASE(Sub, -);
+            CASE(Lsh, << );
+            CASE(Rsh, >> );
+            CASE(Eql, == );
+            CASE(Neq, != );
+            CASE(Greater, >);
+            CASE(Less, <);
+            CASE(Geq, >= );
+            CASE(Leq, <= );
+            CASE(BitAnd, &);
+            CASE(BitXor, ^);
+            CASE(BitOr, | );
+            CASE(And, &&);
+            CASE(Or, || );
+#undef CASE
+
+#define CASE(NAME, OP) case IntrinsicOp::NAME: EmitBinAssignExpr(context, outerPrec, kPrecedence_##NAME, #OP, callExpr); return
+            CASE(Assign, =);
+            CASE(AddAssign, +=);
+            CASE(SubAssign, -=);
+            CASE(MulAssign, *=);
+            CASE(DivAssign, /=);
+            CASE(ModAssign, %=);
+            CASE(LshAssign, <<=);
+            CASE(RshAssign, >>=);
+            CASE(OrAssign, |=);
+            CASE(AndAssign, &=);
+            CASE(XorAssign, ^=);
+#undef CASE
+
+        case IntrinsicOp::Sequence: EmitBinExpr(context, outerPrec, kPrecedence_Comma, ",", callExpr); return;
+
+#define CASE(NAME, OP) case IntrinsicOp::NAME: EmitUnaryExpr(context, outerPrec, kPrecedence_Prefix, #OP, "", callExpr); return
+            CASE(Neg, -);
+            CASE(Not, !);
+            CASE(BitNot, ~);
+#undef CASE
+
+#define CASE(NAME, OP) case IntrinsicOp::NAME: EmitUnaryAssignExpr(context, outerPrec, kPrecedence_Prefix, #OP, "", callExpr); return
+            CASE(PreInc, ++);
+            CASE(PreDec, --);
+#undef CASE
+
+#define CASE(NAME, OP) case IntrinsicOp::NAME: EmitUnaryAssignExpr(context, outerPrec, kPrecedence_Postfix, "", #OP, callExpr); return
+            CASE(PostInc, ++);
+            CASE(PostDec, --);
+#undef CASE
+
+            case IntrinsicOp::InnerProduct_Vector_Vector:
+                // HLSL allows `mul()` to be used as a synonym for `dot()`,
+                // so we need to translate to `dot` for GLSL
+                if (context->target == CodeGenTarget::GLSL)
+                {
+                    Emit(context, "dot(");
+                    EmitExpr(context, callExpr->Arguments[0]);
+                    Emit(context, ", ");
+                    EmitExpr(context, callExpr->Arguments[1]);
+                    Emit(context, ")");
+                    return;
+                }
+                break;
+
+            case IntrinsicOp::InnerProduct_Matrix_Matrix:
+            case IntrinsicOp::InnerProduct_Matrix_Vector:
+            case IntrinsicOp::InnerProduct_Vector_Matrix:
+                // HLSL exposes these with the `mul()` function, while GLSL uses ordinary
+                // `operator*`.
+                //
+                // The other critical detail here is that the way we handle matrix
+                // conventions requires that the operands to the product be swapped.
+                if (context->target == CodeGenTarget::GLSL)
+                {
+                    Emit(context, "((");
+                    EmitExpr(context, callExpr->Arguments[1]);
+                    Emit(context, ") * (");
+                    EmitExpr(context, callExpr->Arguments[0]);
+                    Emit(context, "))");
+                    return;
+                }
+                break;
+
+            default:
+                break;
+            }
+
+
+            // We might be calling an intrinsic subscript operation,
+            // and should desugar it accordingly
+            if(auto subscriptDeclRef = funcDeclRef.As<SubscriptDeclRef>())
+            {
+                // 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>())
+                {
+
+                    Emit(context, "(");
+                    EmitExpr(context, memberExpr->BaseExpression);
+                    Emit(context, ")[");
+                    int argCount = callExpr->Arguments.Count();
+                    for (int aa = 0; aa < argCount; ++aa)
+                    {
+                        if (aa != 0) Emit(context, ", ");
+                        EmitExpr(context, callExpr->Arguments[aa]);
+                    }
+                    Emit(context, "]");
+                    return;
+                }
+            }
+        }
+    }
+
+    // Fall through to default handling...
+
+    bool needClose = MaybeEmitParens(context, outerPrec, kPrecedence_Postfix);
+
+    if (auto funcDeclRefExpr = funcExpr.As<DeclRefExpr>())
+    {
+        auto declRef = funcDeclRefExpr->declRef;
+        if (auto ctorDeclRef = declRef.As<ConstructorDeclRef>())
+        {
+            // We really want to emit a reference to the type begin constructed
+            EmitType(context, callExpr->Type);
+        }
+        else
+        {
+            // default case: just emit the decl ref
+            EmitExpr(context, funcExpr);
+        }
+    }
+    else
+    {
+        // default case: just emit the expression
+        EmitPostfixExpr(context, funcExpr);
+    }
+
+    Emit(context, "(");
+    int argCount = callExpr->Arguments.Count();
+    for (int aa = 0; aa < argCount; ++aa)
+    {
+        if (aa != 0) Emit(context, ", ");
+        EmitExpr(context, callExpr->Arguments[aa]);
+    }
+    Emit(context, ")");
+
+    if (needClose)
+    {
+        Emit(context, ")");
+    }
+}
+
+static void EmitExprWithPrecedence(EmitContext* context, RefPtr<ExpressionSyntaxNode> expr, int outerPrec)
+{
+    bool needClose = false;
+    if (auto selectExpr = expr.As<SelectExpressionSyntaxNode>())
+    {
+        needClose = MaybeEmitParens(context, outerPrec, kPrecedence_Conditional);
+
+        EmitExprWithPrecedence(context, selectExpr->Arguments[0], kPrecedence_Conditional);
+        Emit(context, " ? ");
+        EmitExprWithPrecedence(context, selectExpr->Arguments[1], kPrecedence_Conditional);
+        Emit(context, " : ");
+        EmitExprWithPrecedence(context, selectExpr->Arguments[2], kPrecedence_Conditional);
+    }
+    else if (auto callExpr = expr.As<InvokeExpressionSyntaxNode>())
+    {
+        emitCallExpr(context, callExpr, outerPrec);
+    }
+    else if (auto memberExpr = expr.As<MemberExpressionSyntaxNode>())
+    {
+        needClose = MaybeEmitParens(context, outerPrec, kPrecedence_Postfix);
+
+        // TODO(tfoley): figure out a good way to reference
+        // declarations that might be generic and/or might
+        // not be generated as lexically nested declarations...
+
+        // TODO(tfoley): also, probably need to special case
+        // this for places where we are using a built-in...
+
+        auto base = memberExpr->BaseExpression;
+        if (IsBaseExpressionImplicit(context, base))
+        {
+            // don't emit the base expression
+        }
+        else
+        {
+            EmitExprWithPrecedence(context, memberExpr->BaseExpression, kPrecedence_Postfix);
+            Emit(context, ".");
+        }
+
+        emitName(context, memberExpr->declRef.GetName());
+    }
+    else if (auto swizExpr = expr.As<SwizzleExpr>())
+    {
+        needClose = MaybeEmitParens(context, outerPrec, kPrecedence_Postfix);
+
+        EmitExprWithPrecedence(context, swizExpr->base, kPrecedence_Postfix);
+        Emit(context, ".");
+        static const char* kComponentNames[] = { "x", "y", "z", "w" };
+        int elementCount = swizExpr->elementCount;
+        for (int ee = 0; ee < elementCount; ++ee)
+        {
+            Emit(context, kComponentNames[swizExpr->elementIndices[ee]]);
+        }
+    }
+    else if (auto indexExpr = expr.As<IndexExpressionSyntaxNode>())
+    {
+        needClose = MaybeEmitParens(context, outerPrec, kPrecedence_Postfix);
+
+        EmitExprWithPrecedence(context, indexExpr->BaseExpression, kPrecedence_Postfix);
+        Emit(context, "[");
+        EmitExpr(context, indexExpr->IndexExpression);
+        Emit(context, "]");
+    }
+    else if (auto varExpr = expr.As<VarExpressionSyntaxNode>())
+    {
+        needClose = MaybeEmitParens(context, outerPrec, kPrecedence_Atomic);
+
+        // Because of the "rewriter" use case, it is possible that we will
+        // be trying to emit an expression that hasn't been wired up to
+        // any associated declaration. In that case, we will just emit
+        // the variable name.
+        //
+        // TODO: A better long-term solution here is to have a distinct
+        // case for an "unchecked" `NameExpr` that doesn't include
+        // a declaration reference.
+
+        if(varExpr->declRef)
+        {
+            EmitDeclRef(context, varExpr->declRef);
+        }
+        else
+        {
+            emitName(context, varExpr->Variable);
+        }
+    }
+    else if (auto derefExpr = expr.As<DerefExpr>())
+    {
+        // TODO(tfoley): dereference shouldn't always be implicit
+        EmitExprWithPrecedence(context, derefExpr->base, outerPrec);
+    }
+    else if (auto litExpr = expr.As<ConstantExpressionSyntaxNode>())
+    {
+        needClose = MaybeEmitParens(context, outerPrec, kPrecedence_Atomic);
+
+        switch (litExpr->ConstType)
+        {
+        case ConstantExpressionSyntaxNode::ConstantType::Int:
+            Emit(context, litExpr->IntValue);
+            break;
+        case ConstantExpressionSyntaxNode::ConstantType::Float:
+            Emit(context, litExpr->FloatValue);
+            break;
+        case ConstantExpressionSyntaxNode::ConstantType::Bool:
+            Emit(context, litExpr->IntValue ? "true" : "false");
+            break;
+        default:
+            assert(!"unreachable");
+            break;
+        }
+    }
+    else if (auto castExpr = expr.As<TypeCastExpressionSyntaxNode>())
+    {
+        switch(context->target)
+        {
+        case CodeGenTarget::GLSL:
+            // GLSL requires constructor syntax for all conversions
+            EmitType(context, castExpr->Type);
+            Emit(context, "(");
+            EmitExpr(context, castExpr->Expression);
+            Emit(context, ")");
+            break;
+
+        default:
+            // HLSL (and C/C++) prefer cast syntax
+            // (In fact, HLSL doesn't allow constructor syntax for some conversions it allows as a cast)
+            needClose = MaybeEmitParens(context, outerPrec, kPrecedence_Prefix);
+
+            Emit(context, "(");
+            EmitType(context, castExpr->Type);
+            Emit(context, ")(");
+            EmitExpr(context, castExpr->Expression);
+            Emit(context, ")");
+            break;
+        }
+
+    }
+    else if(auto initExpr = expr.As<InitializerListExpr>())
+    {
+        Emit(context, "{ ");
+        for(auto& arg : initExpr->args)
+        {
+            EmitExpr(context, arg);
+            Emit(context, ", ");
+        }
+        Emit(context, "}");
+    }
+    else
+    {
+        throw "unimplemented";
+    }
+    if (needClose)
+    {
+        Emit(context, ")");
+    }
+}
+
+// Types
+
+void Emit(EmitContext* context, RefPtr<IntVal> val)
+{
+    if(auto constantIntVal = val.As<ConstantIntVal>())
+    {
+        Emit(context, constantIntVal->value);
+    }
+    else if(auto varRefVal = val.As<GenericParamIntVal>())
+    {
+        EmitDeclRef(context, varRefVal->declRef);
+    }
+    else
+    {
+        assert(!"unimplemented");
+    }
+}
+
+// represents a declarator for use in emitting types
+struct EDeclarator
+{
+    enum class Flavor
+    {
+        Name,
+        Array,
+        UnsizedArray,
+    };
+    Flavor flavor;
+    EDeclarator* next = nullptr;
+
+    // Used for `Flavor::Name`
+    String name;
+
+    // Used for `Flavor::Array`
+    IntVal* elementCount;
+};
+
+static void EmitDeclarator(EmitContext* context, EDeclarator* declarator)
+{
+    if (!declarator) return;
+
+    Emit(context, " ");
+
+    switch (declarator->flavor)
+    {
+    case EDeclarator::Flavor::Name:
+        emitName(context, declarator->name);
+        break;
+
+    case EDeclarator::Flavor::Array:
+        EmitDeclarator(context, declarator->next);
+        Emit(context, "[");
+        if(auto elementCount = declarator->elementCount)
+        {
+            Emit(context, elementCount);
+        }
+        Emit(context, "]");
+        break;
+
+    case EDeclarator::Flavor::UnsizedArray:
+        EmitDeclarator(context, declarator->next);
+        Emit(context, "[]");
+        break;
+
+    default:
+        assert(!"unreachable");
+        break;
+    }
+}
+
+static void emitGLSLTypePrefix(
+    EmitContext*            context,
+    RefPtr<ExpressionType>  type)
+{
+    if(auto basicElementType = type->As<BasicExpressionType>())
+    {
+        switch (basicElementType->BaseType)
+        {
+        case BaseType::Float:
+            // no prefix
+            break;
+
+        case BaseType::Int:		Emit(context, "i");		break;
+        case BaseType::UInt:	Emit(context, "u");		break;
+        case BaseType::Bool:	Emit(context, "b");		break;
+        default:
+            assert(!"unreachable");
+            break;
+        }
+    }
+    else if(auto vectorType = type->As<VectorExpressionType>())
+    {
+        emitGLSLTypePrefix(context, vectorType->elementType);
+    }
+    else if(auto matrixType = type->As<MatrixExpressionType>())
+    {
+        emitGLSLTypePrefix(context, matrixType->getElementType());
+    }
+    else
+    {
+        assert(!"unreachable");
+    }
+}
+
+static void emitHLSLTextureType(
+    EmitContext*            context,
+    RefPtr<TextureTypeBase> texType)
+{
+    switch(texType->getAccess())
+    {
+    case SLANG_RESOURCE_ACCESS_READ:
+        break;
+
+    case SLANG_RESOURCE_ACCESS_READ_WRITE:
+        Emit(context, "RW");
+        break;
+
+    case SLANG_RESOURCE_ACCESS_RASTER_ORDERED:
+        Emit(context, "RasterizerOrdered");
+        break;
+
+    case SLANG_RESOURCE_ACCESS_APPEND:
+        Emit(context, "Append");
+        break;
+
+    case SLANG_RESOURCE_ACCESS_CONSUME:
+        Emit(context, "Consume");
+        break;
+
+    default:
+        assert(!"unreachable");
+        break;
+    }
+
+    switch (texType->GetBaseShape())
+    {
+    case TextureType::Shape1D:		Emit(context, "Texture1D");		break;
+    case TextureType::Shape2D:		Emit(context, "Texture2D");		break;
+    case TextureType::Shape3D:		Emit(context, "Texture3D");		break;
+    case TextureType::ShapeCube:	Emit(context, "TextureCube");	break;
+    default:
+        assert(!"unreachable");
+        break;
+    }
+
+    if (texType->isMultisample())
+    {
+        Emit(context, "MS");
+    }
+    if (texType->isArray())
+    {
+        Emit(context, "Array");
+    }
+    Emit(context, "<");
+    EmitType(context, texType->elementType);
+    Emit(context, ">");
+}
+
+static void emitGLSLTextureOrTextureSamplerType(
+    EmitContext*            context,
+    RefPtr<TextureTypeBase> type,
+    char const*             baseName)
+{
+    emitGLSLTypePrefix(context, type->elementType);
+
+    Emit(context, baseName);
+    switch (type->GetBaseShape())
+    {
+    case TextureType::Shape1D:		Emit(context, "1D");		break;
+    case TextureType::Shape2D:		Emit(context, "2D");		break;
+    case TextureType::Shape3D:		Emit(context, "3D");		break;
+    case TextureType::ShapeCube:	Emit(context, "Cube");	break;
+    default:
+        assert(!"unreachable");
+        break;
+    }
+
+    if (type->isMultisample())
+    {
+        Emit(context, "MS");
+    }
+    if (type->isArray())
+    {
+        Emit(context, "Array");
+    }
+}
+
+static void emitGLSLTextureType(
+    EmitContext*        context,
+    RefPtr<TextureType> texType)
+{
+    emitGLSLTextureOrTextureSamplerType(context, texType, "texture");
+}
+
+static void emitGLSLTextureSamplerType(
+    EmitContext*                context,
+    RefPtr<TextureSamplerType>  type)
+{
+    emitGLSLTextureOrTextureSamplerType(context, type, "sampler");
+}
+
+static void emitGLSLImageType(
+    EmitContext*            context,
+    RefPtr<GLSLImageType>   type)
+{
+    emitGLSLTextureOrTextureSamplerType(context, type, "image");
+}
+
+static void emitTextureType(
+    EmitContext*        context,
+    RefPtr<TextureType> texType)
+{
+    switch(context->target)
+    {
+    case CodeGenTarget::HLSL:
+        emitHLSLTextureType(context, texType);
+        break;
+
+    case CodeGenTarget::GLSL:
+        emitGLSLTextureType(context, texType);
+        break;
+
+    default:
+        assert(!"unreachable");
+        break;
+    }
+}
+
+static void emitTextureSamplerType(
+    EmitContext*                context,
+    RefPtr<TextureSamplerType>  type)
+{
+    switch(context->target)
+    {
+    case CodeGenTarget::GLSL:
+        emitGLSLTextureSamplerType(context, type);
+        break;
+
+    default:
+        assert(!"unreachable");
+        break;
+    }
+}
+
+static void emitImageType(
+    EmitContext*            context,
+    RefPtr<GLSLImageType>   type)
+{
+    switch(context->target)
+    {
+    case CodeGenTarget::HLSL:
+        emitHLSLTextureType(context, type);
+        break;
+
+    case CodeGenTarget::GLSL:
+        emitGLSLImageType(context, type);
+        break;
+
+    default:
+        assert(!"unreachable");
+        break;
+    }
+}
+
+static void EmitType(EmitContext* context, RefPtr<ExpressionType> type, EDeclarator* declarator)
+{
+    if (auto basicType = type->As<BasicExpressionType>())
+    {
+        switch (basicType->BaseType)
+        {
+        case BaseType::Void:	Emit(context, "void");		break;
+        case BaseType::Int:		Emit(context, "int");		break;
+        case BaseType::Float:	Emit(context, "float");		break;
+        case BaseType::UInt:	Emit(context, "uint");		break;
+        case BaseType::Bool:	Emit(context, "bool");		break;
+        default:
+            assert(!"unreachable");
+            break;
+        }
+
+        EmitDeclarator(context, declarator);
+        return;
+    }
+    else if (auto vecType = type->As<VectorExpressionType>())
+    {
+        switch(context->target)
+        {
+        case CodeGenTarget::GLSL:
+        case CodeGenTarget::GLSL_Vulkan:
+        case CodeGenTarget::GLSL_Vulkan_OneDesc:
+            {
+                emitGLSLTypePrefix(context, vecType->elementType);
+                Emit(context, "vec");
+                Emit(context, vecType->elementCount);
+            }
+            break;
+
+        case CodeGenTarget::HLSL:
+            // TODO(tfoley): should really emit these with sugar
+            Emit(context, "vector<");
+            EmitType(context, vecType->elementType);
+            Emit(context, ",");
+            Emit(context, vecType->elementCount);
+            Emit(context, ">");
+            break;
+
+        default:
+            assert(!"unreachable");
+            break;
+        }
+
+        Emit(context, " ");
+        EmitDeclarator(context, declarator);
+        return;
+    }
+    else if (auto matType = type->As<MatrixExpressionType>())
+    {
+        switch(context->target)
+        {
+        case CodeGenTarget::GLSL:
+        case CodeGenTarget::GLSL_Vulkan:
+        case CodeGenTarget::GLSL_Vulkan_OneDesc:
+            {
+                emitGLSLTypePrefix(context, matType->getElementType());
+                Emit(context, "mat");
+                Emit(context, matType->getRowCount());
+                // TODO(tfoley): only emit the next bit
+                // for non-square matrix
+                Emit(context, "x");
+                Emit(context, matType->getColumnCount());
+            }
+            break;
+
+        case CodeGenTarget::HLSL:
+            // TODO(tfoley): should really emit these with sugar
+            Emit(context, "matrix<");
+            EmitType(context, matType->getElementType());
+            Emit(context, ",");
+            Emit(context, matType->getRowCount());
+            Emit(context, ",");
+            Emit(context, matType->getColumnCount());
+            Emit(context, "> ");
+            break;
+
+        default:
+            assert(!"unreachable");
+            break;
+        }
+
+        Emit(context, " ");
+        EmitDeclarator(context, declarator);
+        return;
+    }
+    else if (auto texType = type->As<TextureType>())
+    {
+        emitTextureType(context, texType);
+        Emit(context, " ");
+        EmitDeclarator(context, declarator);
+        return;
+    }
+    else if (auto textureSamplerType = type->As<TextureSamplerType>())
+    {
+        emitTextureSamplerType(context, textureSamplerType);
+        Emit(context, " ");
+        EmitDeclarator(context, declarator);
+        return;
+    }
+    else if (auto imageType = type->As<GLSLImageType>())
+    {
+        emitImageType(context, imageType);
+        Emit(context, " ");
+        EmitDeclarator(context, declarator);
+        return;
+    }
+    else if (auto samplerStateType = type->As<SamplerStateType>())
+    {
+        switch(context->target)
+        {
+        case CodeGenTarget::HLSL:
+        default:
+            switch (samplerStateType->flavor)
+            {
+            case SamplerStateType::Flavor::SamplerState:			Emit(context, "SamplerState");				break;
+            case SamplerStateType::Flavor::SamplerComparisonState:	Emit(context, "SamplerComparisonState");	break;
+            default:
+                assert(!"unreachable");
+                break;
+            }
+            break;
+
+        case CodeGenTarget::GLSL:
+            Emit(context, "sampler");
+            break;
+        }
+
+
+        EmitDeclarator(context, declarator);
+        return;
+    }
+    else if (auto declRefType = type->As<DeclRefType>())
+    {
+        EmitDeclRef(context,  declRefType->declRef);
+
+        EmitDeclarator(context, declarator);
+        return;
+    }
+    else if( auto arrayType = type->As<ArrayExpressionType>() )
+    {
+        EDeclarator arrayDeclarator;
+        arrayDeclarator.next = declarator;
+
+        if(arrayType->ArrayLength)
+        {
+            arrayDeclarator.flavor = EDeclarator::Flavor::Array;
+            arrayDeclarator.elementCount = arrayType->ArrayLength.Ptr();
+        }
+        else
+        {
+            arrayDeclarator.flavor = EDeclarator::Flavor::UnsizedArray;
+        }
+
+
+        EmitType(context, arrayType->BaseType, &arrayDeclarator);
+        return;
+    }
+
+    throw "unimplemented";
+}
+
+static void EmitType(EmitContext* context, RefPtr<ExpressionType> type, String const& name)
+{
+    EDeclarator nameDeclarator;
+    nameDeclarator.flavor = EDeclarator::Flavor::Name;
+    nameDeclarator.name = name;
+    EmitType(context, type, &nameDeclarator);
+}
+
+static void EmitType(EmitContext* context, RefPtr<ExpressionType> type)
+{
+    EmitType(context, type, nullptr);
+}
+
+// Statements
+
+// Emit a statement as a `{}`-enclosed block statement, but avoid adding redundant
+// curly braces if the statement is itself a block statement.
+static void EmitBlockStmt(EmitContext* context, RefPtr<StatementSyntaxNode> stmt)
+{
+    // TODO(tfoley): support indenting
+    Emit(context, "{\n");
+    if( auto blockStmt = stmt.As<BlockStatementSyntaxNode>() )
+    {
+        for (auto s : blockStmt->Statements)
+        {
+            EmitStmt(context, s);
+        }
+    }
+    else
+    {
+        EmitStmt(context, stmt);
+    }
+    Emit(context, "}\n");
+}
+
+static void EmitLoopAttributes(EmitContext* context, RefPtr<StatementSyntaxNode> decl)
+{
+    // TODO(tfoley): There really ought to be a semantic checking step for attributes,
+    // that turns abstract syntax into a concrete hierarchy of attribute types (e.g.,
+    // a specific `LoopModifier` or `UnrollModifier`).
+
+    for(auto attr : decl->GetModifiersOfType<HLSLUncheckedAttribute>())
+    {
+        if(attr->nameToken.Content == "loop")
+        {
+            Emit(context, "[loop]");
+        }
+        else if(attr->nameToken.Content == "unroll")
+        {
+            Emit(context, "[unroll]");
+        }
+    }
+}
+
+static void advanceToSourceLocation(
+    EmitContext*        context,
+    CodePosition const& sourceLocation)
+{
+    // If we are currently emitting code at a source location with
+    // a differnet file or line, *or* if the source location is
+    // somehow later on the line than what we want to emit,
+    // then we need to emit a new `#line` directive.
+    if(sourceLocation.FileName != context->loc.FileName
+        || sourceLocation.Line != context->loc.Line
+        || sourceLocation.Col < context->loc.Col)
+    {
+        emitRawText(context, "\n#line ");
+
+        char buffer[16];
+        sprintf(buffer, "%d", sourceLocation.Line);
+        emitRawText(context, buffer);
+
+        emitRawText(context, "\"");
+        for(auto c : sourceLocation.FileName)
+        {
+            char charBuffer[] = { c, 0 };
+            switch(c)
+            {
+            default:
+                emitRawText(context, charBuffer);
+                break;
+
+            // TODO: should probably canonicalize paths to not use backslash somewhere else
+            // in the compilation pipeline...
+            case '\\':
+                emitRawText(context, "/");
+                break;
+            }
+        }
+        emitRawText(context, "\"\n");
+    
+        context->loc.FileName = sourceLocation.FileName;
+        context->loc.Line = sourceLocation.Line;
+        context->loc.Col = 1;
+    }
+
+    // Now indent up to the appropriate column, so that error messages
+    // that reference columns will be correct.
+    //
+    // TODO: This logic does not take into account whether indentation
+    // came in as spaces or tabs, so there is necessarily going to be
+    // coupling between how the downstream compiler counts columns,
+    // and how we do.
+    if(sourceLocation.Col > context->loc.Col)
+    {
+        int delta = sourceLocation.Col - context->loc.Col;
+        for( int ii = 0; ii < delta; ++ii )
+        {
+            emitRawText(context, " ");
+        }
+        context->loc.Col = sourceLocation.Col;
+    }
+}
+
+static void emitTokenWithLocation(EmitContext* context, Token const& token)
+{
+    if( token.Position.FileName.Length() != 0 )
+    {
+        advanceToSourceLocation(context, token.Position);
+    }
+    else
+    {
+        // If we don't have the original position info, we need to play
+        // it safe and emit whitespace to line things up nicely
+
+        if(token.flags & TokenFlag::AtStartOfLine)
+            Emit(context, "\n");
+        // TODO(tfoley): macro expansion can currently lead to whitespace getting dropped,
+        // so we will just insert it aggressively, to play it safe.
+        else //  if(token.flags & TokenFlag::AfterWhitespace)
+            Emit(context, " ");
+    }
+
+    // Emit the raw textual content of the token
+    emit(context, token.Content);
+}
+
+static void EmitUnparsedStmt(EmitContext* context, RefPtr<UnparsedStmt> stmt)
+{
+    // TODO: actually emit the tokens that made up the statement...
+    Emit(context, "{\n");
+    for( auto& token : stmt->tokens )
+    {
+        emitTokenWithLocation(context, token);
+    }
+    Emit(context, "}\n");
+}
+
+static void EmitStmt(EmitContext* context, RefPtr<StatementSyntaxNode> stmt)
+{
+    if (auto blockStmt = stmt.As<BlockStatementSyntaxNode>())
+    {
+        EmitBlockStmt(context, blockStmt);
+        return;
+    }
+    else if( auto unparsedStmt = stmt.As<UnparsedStmt>() )
+    {
+        EmitUnparsedStmt(context, unparsedStmt);
+        return;
+    }
+    else if (auto exprStmt = stmt.As<ExpressionStatementSyntaxNode>())
+    {
+        EmitExpr(context, exprStmt->Expression);
+        Emit(context, ";\n");
+        return;
+    }
+    else if (auto returnStmt = stmt.As<ReturnStatementSyntaxNode>())
+    {
+        Emit(context, "return");
+        if (auto expr = returnStmt->Expression)
+        {
+            Emit(context, " ");
+            EmitExpr(context, expr);
+        }
+        Emit(context, ";\n");
+        return;
+    }
+    else if (auto declStmt = stmt.As<VarDeclrStatementSyntaxNode>())
+    {
+        EmitDecl(context, declStmt->decl);
+        return;
+    }
+    else if (auto ifStmt = stmt.As<IfStatementSyntaxNode>())
+    {
+        Emit(context, "if(");
+        EmitExpr(context, ifStmt->Predicate);
+        Emit(context, ")\n");
+        EmitBlockStmt(context, ifStmt->PositiveStatement);
+        if(auto elseStmt = ifStmt->NegativeStatement)
+        {
+            Emit(context, "\nelse\n");
+            EmitBlockStmt(context, elseStmt);
+        }
+        return;
+    }
+    else if (auto forStmt = stmt.As<ForStatementSyntaxNode>())
+    {
+        EmitLoopAttributes(context, forStmt);
+
+        Emit(context, "for(");
+        if (auto initStmt = forStmt->InitialStatement)
+        {
+            EmitStmt(context, initStmt);
+        }
+        else
+        {
+            Emit(context, ";");
+        }
+        if (auto testExp = forStmt->PredicateExpression)
+        {
+            EmitExpr(context, testExp);
+        }
+        Emit(context, ";");
+        if (auto incrExpr = forStmt->SideEffectExpression)
+        {
+            EmitExpr(context, incrExpr);
+        }
+        Emit(context, ")\n");
+        EmitBlockStmt(context, forStmt->Statement);
+        return;
+    }
+    else if (auto discardStmt = stmt.As<DiscardStatementSyntaxNode>())
+    {
+        Emit(context, "discard;\n");
+        return;
+    }
+    else if (auto emptyStmt = stmt.As<EmptyStatementSyntaxNode>())
+    {
+        return;
+    }
+    else if (auto switchStmt = stmt.As<SwitchStmt>())
+    {
+        Emit(context, "switch(");
+        EmitExpr(context, switchStmt->condition);
+        Emit(context, ")\n");
+        EmitBlockStmt(context, switchStmt->body);
+        return;
+    }
+    else if (auto caseStmt = stmt.As<CaseStmt>())
+    {
+        Emit(context, "case ");
+        EmitExpr(context, caseStmt->expr);
+        Emit(context, ":\n");
+        return;
+    }
+    else if (auto defaultStmt = stmt.As<DefaultStmt>())
+    {
+        Emit(context, "default:{}\n");
+        return;
+    }
+    else if (auto breakStmt = stmt.As<BreakStatementSyntaxNode>())
+    {
+        Emit(context, "break;\n");
+        return;
+    }
+    else if (auto continueStmt = stmt.As<ContinueStatementSyntaxNode>())
+    {
+        Emit(context, "continue;\n");
+        return;
+    }
+
+    throw "unimplemented";
+
+}
+
+// Declaration References
+
+static void EmitVal(EmitContext* context, RefPtr<Val> val)
+{
+    if (auto type = val.As<ExpressionType>())
+    {
+        EmitType(context, type);
+    }
+    else if (auto intVal = val.As<IntVal>())
+    {
+        Emit(context, intVal);
+    }
+    else
+    {
+        // Note(tfoley): ignore unhandled cases for semantics for now...
+//		assert(!"unimplemented");
+    }
+}
+
+static void EmitDeclRef(EmitContext* context, DeclRef declRef)
+{
+    // TODO: need to qualify a declaration name based on parent scopes/declarations
+
+    // Emit the name for the declaration itself
+    emitName(context, declRef.GetName());
+
+    // If the declaration is nested directly in a generic, then
+    // we need to output the generic arguments here
+    auto parentDeclRef = declRef.GetParent();
+    if (auto genericDeclRef = parentDeclRef.As<GenericDeclRef>())
+    {
+        // Only do this for declarations of appropriate flavors
+        if(auto funcDeclRef = declRef.As<FuncDeclBaseRef>())
+        {
+            // Don't emit generic arguments for functions, because HLSL doesn't allow them
+            return;
+        }
+
+        Substitutions* subst = declRef.substitutions.Ptr();
+        Emit(context, "<");
+        int argCount = subst->args.Count();
+        for (int aa = 0; aa < argCount; ++aa)
+        {
+            if (aa != 0) Emit(context, ",");
+            EmitVal(context, subst->args[aa]);
+        }
+        Emit(context, ">");
+    }
+
+}
+
+// Declarations
+
+// Emit any modifiers that should go in front of a declaration
+static void EmitModifiers(EmitContext* context, RefPtr<Decl> decl)
+{
+    // Emit any GLSL `layout` modifiers first
+    bool anyLayout = false;
+    for( auto mod : decl->GetModifiersOfType<GLSLUnparsedLayoutModifier>())
+    {
+        if(!anyLayout)
+        {
+            Emit(context, "layout(");
+            anyLayout = true;
+        }
+        else
+        {
+            Emit(context, ", ");
+        }
+
+        emit(context, mod->nameToken.Content);
+        if(mod->valToken.Type != TokenType::Unknown)
+        {
+            Emit(context, " = ");
+            emit(context, mod->valToken.Content);
+        }
+    }
+    if(anyLayout)
+    {
+        Emit(context, ")\n");
+    }
+
+    for (auto mod = decl->modifiers.first; mod; mod = mod->next)
+    {
+        if (0) {}
+
+        #define CASE(TYPE, KEYWORD) \
+            else if(auto mod_##TYPE = mod.As<TYPE>()) Emit(context, #KEYWORD " ")
+
+        CASE(RowMajorLayoutModifier, row_major);
+        CASE(ColumnMajorLayoutModifier, column_major);
+        CASE(HLSLNoInterpolationModifier, nointerpolation);
+        CASE(HLSLPreciseModifier, precise);
+        CASE(HLSLEffectSharedModifier, shared);
+        CASE(HLSLGroupSharedModifier, groupshared);
+        CASE(HLSLStaticModifier, static);
+        CASE(HLSLUniformModifier, uniform);
+        CASE(HLSLVolatileModifier, volatile);
+
+        CASE(InOutModifier, inout);
+        CASE(InModifier, in);
+        CASE(OutModifier, out);
+
+        CASE(HLSLPointModifier, point);
+        CASE(HLSLLineModifier, line);
+        CASE(HLSLTriangleModifier, triangle);
+        CASE(HLSLLineAdjModifier, lineadj);
+        CASE(HLSLTriangleAdjModifier, triangleadj);
+
+        CASE(HLSLLinearModifier, linear);
+        CASE(HLSLSampleModifier, sample);
+        CASE(HLSLCentroidModifier, centroid);
+
+        CASE(ConstModifier, const);
+
+        #undef CASE
+
+        // TODO: eventually we should be checked these modifiers, but for
+        // now we can emit them unchecked, I guess
+        else if (auto uncheckedAttr = mod.As<HLSLAttribute>())
+        {
+            Emit(context, "[");
+            emit(context, uncheckedAttr->nameToken.Content);
+            auto& args = uncheckedAttr->args;
+            auto argCount = args.Count();
+            if (argCount != 0)
+            {
+                Emit(context, "(");
+                for (int aa = 0; aa < argCount; ++aa)
+                {
+                    if (aa != 0) Emit(context, ", ");
+                    EmitExpr(context, args[aa]);
+                }
+                Emit(context, ")");
+            }
+            Emit(context, "]");
+        }
+
+        else if(auto simpleModifier = mod.As<SimpleModifier>())
+        {
+            emit(context, simpleModifier->nameToken.Content);
+            Emit(context, " ");
+        }
+
+        else
+        {
+            // skip any extra modifiers
+        }
+    }
+}
+
+
+typedef unsigned int ESemanticMask;
+enum
+{
+    kESemanticMask_None = 0,
+
+    kESemanticMask_NoPackOffset = 1 << 0,
+
+    kESemanticMask_Default = kESemanticMask_NoPackOffset,
+};
+
+static void EmitSemantic(EmitContext* context, RefPtr<HLSLSemantic> semantic, ESemanticMask /*mask*/)
+{
+    if (auto simple = semantic.As<HLSLSimpleSemantic>())
+    {
+        Emit(context, ": ");
+        emit(context, simple->name.Content);
+    }
+    else if(auto registerSemantic = semantic.As<HLSLRegisterSemantic>())
+    {
+        // Don't print out semantic from the user, since we are going to print the same thing our own way...
+#if 0
+        Emit(context, ": register(");
+        Emit(context, registerSemantic->registerName.Content);
+        if(registerSemantic->componentMask.Type != TokenType::Unknown)
+        {
+            Emit(context, ".");
+            Emit(context, registerSemantic->componentMask.Content);
+        }
+        Emit(context, ")");
+#endif
+    }
+    else if(auto packOffsetSemantic = semantic.As<HLSLPackOffsetSemantic>())
+    {
+        // Don't print out semantic from the user, since we are going to print the same thing our own way...
+#if 0
+        if(mask & kESemanticMask_NoPackOffset)
+            return;
+
+        Emit(context, ": packoffset(");
+        Emit(context, packOffsetSemantic->registerName.Content);
+        if(packOffsetSemantic->componentMask.Type != TokenType::Unknown)
+        {
+            Emit(context, ".");
+            Emit(context, packOffsetSemantic->componentMask.Content);
+        }
+        Emit(context, ")");
+#endif
+    }
+    else
+    {
+        assert(!"unimplemented");
+    }
+}
+
+
+static void EmitSemantics(EmitContext* context, RefPtr<Decl> decl, ESemanticMask mask = kESemanticMask_Default )
+{
+    // Don't emit semantics if we aren't translating down to HLSL
+    switch (context->target)
+    {
+    case CodeGenTarget::HLSL:
+        break;
+
+    default:
+        return;
+    }
+
+    for (auto mod = decl->modifiers.first; mod; mod = mod->next)
+    {
+        auto semantic = mod.As<HLSLSemantic>();
+        if (!semantic)
+            continue;
+
+        EmitSemantic(context, semantic, mask);
+    }
+}
+
+static void EmitDeclsInContainer(EmitContext* context, RefPtr<ContainerDecl> container)
+{
+    for (auto member : container->Members)
+    {
+        EmitDecl(context, member);
+    }
+}
+
+static void EmitDeclsInContainerUsingLayout(
+    EmitContext*                context,
+    RefPtr<ContainerDecl>       container,
+    RefPtr<StructTypeLayout>    containerLayout)
+{
+    for (auto member : container->Members)
+    {
+        RefPtr<VarLayout> memberLayout;
+        if( containerLayout->mapVarToLayout.TryGetValue(member.Ptr(), memberLayout) )
+        {
+            EmitDeclUsingLayout(context, member, memberLayout);
+        }
+        else
+        {
+            // No layout for this decl
+            EmitDecl(context, member);
+        }
+    }
+}
+
+static void EmitTypeDefDecl(EmitContext* context, RefPtr<TypeDefDecl> decl)
+{
+    // TODO(tfoley): check if current compilation target even supports typedefs
+
+    Emit(context, "typedef ");
+    EmitType(context, decl->Type, decl->Name.Content);
+    Emit(context, ";\n");
+}
+
+static void EmitStructDecl(EmitContext* context, RefPtr<StructSyntaxNode> decl)
+{
+    // Don't emit a declaration that was only generated implicitly, for
+    // the purposes of semantic checking.
+    if(decl->HasModifier<ImplicitParameterBlockElementTypeModifier>())
+        return;
+
+    Emit(context, "struct ");
+    emitName(context, decl->Name.Content);
+    Emit(context, "\n{\n");
+
+    // TODO(tfoley): Need to hoist members functions, etc. out to global scope
+    EmitDeclsInContainer(context, decl);
+
+    Emit(context, "};\n");
+}
+
+// Shared emit logic for variable declarations (used for parameters, locals, globals, fields)
+static void EmitVarDeclCommon(EmitContext* context, VarDeclBaseRef declRef)
+{
+    EmitModifiers(context, declRef.GetDecl());
+
+    EmitType(context, declRef.GetType(), declRef.GetName());
+
+    EmitSemantics(context, declRef.GetDecl());
+
+    // TODO(tfoley): technically have to apply substitution here too...
+    if (auto initExpr = declRef.GetDecl()->Expr)
+    {
+        Emit(context, " = ");
+        EmitExpr(context, initExpr);
+    }
+}
+
+// Shared emit logic for variable declarations (used for parameters, locals, globals, fields)
+static void EmitVarDeclCommon(EmitContext* context, RefPtr<VarDeclBase> decl)
+{
+    EmitVarDeclCommon(context, DeclRef(decl.Ptr(), nullptr).As<VarDeclBaseRef>());
+}
+
+// Emit a single `regsiter` semantic, as appropriate for a given resource-type-specific layout info
+static void emitHLSLRegisterSemantic(
+    EmitContext*                    context,
+    VarLayout::ResourceInfo const&  info)
+{
+    if( info.kind == LayoutResourceKind::Uniform )
+    {
+        size_t offset = info.index;
+
+        // The HLSL `c` register space is logically grouped in 16-byte registers,
+        // while we try to traffic in byte offsets. That means we need to pick
+        // a register number, based on the starting offset in 16-byte register
+        // units, and then a "component" within that register, based on 4-byte
+        // offsets from there. We cannot support more fine-grained offsets than that.
+
+        Emit(context, ": packoffset(c");
+
+        // Size of a logical `c` register in bytes
+        auto registerSize = 16;
+
+        // Size of each component of a logical `c` register, in bytes
+        auto componentSize = 4;
+
+        size_t startRegister = offset / registerSize;
+        Emit(context, int(startRegister));
+
+        size_t byteOffsetInRegister = offset % registerSize;
+
+        // If this field doesn't start on an even register boundary,
+        // then we need to emit additional information to pick the
+        // right component to start from
+        if (byteOffsetInRegister != 0)
+        {
+            // The value had better occupy a whole number of components.
+            assert(byteOffsetInRegister % componentSize == 0);
+
+            size_t startComponent = byteOffsetInRegister / componentSize;
+
+            static const char* kComponentNames[] = {"x", "y", "z", "w"};
+            Emit(context, ".");
+            Emit(context, kComponentNames[startComponent]);
+        }
+        Emit(context, ")");
+    }
+    else
+    {
+        Emit(context, ": register(");
+        switch( info.kind )
+        {
+        case LayoutResourceKind::ConstantBuffer:
+            Emit(context, "b");
+            break;
+        case LayoutResourceKind::ShaderResource:
+            Emit(context, "t");
+            break;
+        case LayoutResourceKind::UnorderedAccess:
+            Emit(context, "u");
+            break;
+        case LayoutResourceKind::SamplerState:
+            Emit(context, "s");
+            break;
+        default:
+            assert(!"unexpected");
+            break;
+        }
+        Emit(context, info.index);
+        if(info.space)
+        {
+            Emit(context, ", space");
+            Emit(context, info.space);
+        }
+        Emit(context, ")");
+    }
+}
+
+// Emit all the `register` semantics that are appropriate for a particular variable layout
+static void emitHLSLRegisterSemantics(
+    EmitContext*        context,
+    RefPtr<VarLayout>   layout)
+{
+    if (!layout) return;
+
+    switch( context->target )
+    {
+    default:
+        return;
+
+    case CodeGenTarget::HLSL:
+        break;
+    }
+
+    for( auto rr : layout->resourceInfos )
+    {
+        emitHLSLRegisterSemantic(context, rr);
+    }
+}
+
+static void emitHLSLParameterBlockDecl(
+    EmitContext*                    context,
+    RefPtr<VarDeclBase>             varDecl,
+    RefPtr<ParameterBlockType>      parameterBlockType,
+    RefPtr<VarLayout>               layout)
+{
+    // The data type that describes where stuff in the constant buffer should go
+    RefPtr<ExpressionType> dataType = parameterBlockType->elementType;
+
+    // We expect/require the data type to be a user-defined `struct` type
+    auto declRefType = dataType->As<DeclRefType>();
+    assert(declRefType);
+
+    // We expect to always have layout information
+    assert(layout);
+
+    // We expect the layout to be for a structured type...
+    RefPtr<ParameterBlockTypeLayout> bufferLayout = layout->typeLayout.As<ParameterBlockTypeLayout>();
+    assert(bufferLayout);
+
+    RefPtr<StructTypeLayout> structTypeLayout = bufferLayout->elementTypeLayout.As<StructTypeLayout>();
+    assert(structTypeLayout);
+
+    if( auto constantBufferType = parameterBlockType->As<ConstantBufferType>() )
+    {
+        Emit(context, "cbuffer ");
+    }
+    else if( auto textureBufferType = parameterBlockType->As<TextureBufferType>() )
+    {
+        Emit(context, "tbuffer ");
+    }
+
+    if( auto reflectionNameModifier = varDecl->FindModifier<ParameterBlockReflectionName>() )
+    {
+        Emit(context, " ");
+        emitName(context, reflectionNameModifier->nameToken.Content);
+    }
+
+    EmitSemantics(context, varDecl, kESemanticMask_None);
+
+    auto info = layout->FindResourceInfo(LayoutResourceKind::ConstantBuffer);
+    assert(info);
+    emitHLSLRegisterSemantic(context, *info);
+
+    Emit(context, "\n{\n");
+    if (auto structRef = declRefType->declRef.As<StructDeclRef>())
+    {
+        for (auto field : structRef.GetMembersOfType<FieldDeclRef>())
+        {
+            EmitVarDeclCommon(context, field);
+
+            RefPtr<VarLayout> fieldLayout;
+            structTypeLayout->mapVarToLayout.TryGetValue(field.GetDecl(), fieldLayout);
+            assert(fieldLayout);
+
+            // Emit explicit layout annotations for every field
+            for( auto rr : fieldLayout->resourceInfos )
+            {
+                auto kind = rr.kind;
+
+                auto offsetResource = rr;
+
+                if(kind != LayoutResourceKind::Uniform)
+                {
+                    // Add the base index from the cbuffer into the index of the field
+                    //
+                    // TODO(tfoley): consider maybe not doing this, since it actually
+                    // complicates logic around constant buffers...
+
+                    // If the member of the cbuffer uses a resource, it had better
+                    // appear as part of the cubffer layout as well.
+                    auto cbufferResource = layout->FindResourceInfo(kind);
+                    assert(cbufferResource);
+
+                    offsetResource.index += cbufferResource->index;
+                    offsetResource.space += cbufferResource->space;
+                }
+
+                emitHLSLRegisterSemantic(context, offsetResource);
+            }
+
+            Emit(context, ";\n");
+        }
+    }
+    Emit(context, "}\n");
+}
+
+static void
+emitGLSLLayoutQualifier(
+    EmitContext*                    context,
+    VarLayout::ResourceInfo const&  info)
+{
+    switch(info.kind)
+    {
+    case LayoutResourceKind::Uniform:
+        Emit(context, "layout(offset = ");
+        Emit(context, info.index);
+        Emit(context, ")\n");
+        break;
+
+    case LayoutResourceKind::VertexInput:
+    case LayoutResourceKind::FragmentOutput:
+        Emit(context, "layout(location = ");
+        Emit(context, info.index);
+        Emit(context, ")\n");
+        break;
+
+    case LayoutResourceKind::SpecializationConstant:
+        Emit(context, "layout(constant_id = ");
+        Emit(context, info.index);
+        Emit(context, ")\n");
+        break;
+
+    case LayoutResourceKind::ConstantBuffer:
+    case LayoutResourceKind::ShaderResource:
+    case LayoutResourceKind::UnorderedAccess:
+    case LayoutResourceKind::SamplerState:
+    case LayoutResourceKind::DescriptorTableSlot:
+        Emit(context, "layout(binding = ");
+        Emit(context, info.index);
+        if(info.space)
+        {
+            Emit(context, ", set = ");
+            Emit(context, info.space);
+        }
+        Emit(context, ")\n");
+        break;
+    }
+}
+
+static void
+emitGLSLLayoutQualifiers(
+    EmitContext*                    context,
+    RefPtr<VarLayout>               layout)
+{
+    if(!layout) return;
+
+    switch( context->target )
+    {
+    default:
+        return;
+
+    case CodeGenTarget::GLSL:
+        break;
+    }
+
+    for( auto info : layout->resourceInfos )
+    {
+        emitGLSLLayoutQualifier(context, info);
+    }
+}
+
+static void emitGLSLParameterBlockDecl(
+    EmitContext*                    context,
+    RefPtr<VarDeclBase>             varDecl,
+    RefPtr<ParameterBlockType>      parameterBlockType,
+    RefPtr<VarLayout>               layout)
+{
+    // The data type that describes where stuff in the constant buffer should go
+    RefPtr<ExpressionType> dataType = parameterBlockType->elementType;
+
+    // We expect/require the data type to be a user-defined `struct` type
+    auto declRefType = dataType->As<DeclRefType>();
+    assert(declRefType);
+
+    // We expect to always have layout information
+    assert(layout);
+
+    // We expect the layout to be for a structured type...
+    RefPtr<ParameterBlockTypeLayout> bufferLayout = layout->typeLayout.As<ParameterBlockTypeLayout>();
+    assert(bufferLayout);
+
+    RefPtr<StructTypeLayout> structTypeLayout = bufferLayout->elementTypeLayout.As<StructTypeLayout>();
+    assert(structTypeLayout);
+
+    emitGLSLLayoutQualifiers(context, layout);
+
+    EmitModifiers(context, varDecl);
+
+    // Emit an apprpriate declaration keyword based on the kind of block
+    if (parameterBlockType->As<ConstantBufferType>())
+    {
+        Emit(context, "uniform");
+    }
+    else if (parameterBlockType->As<GLSLInputParameterBlockType>())
+    {
+        Emit(context, "in");
+    }
+    else if (parameterBlockType->As<GLSLOutputParameterBlockType>())
+    {
+        Emit(context, "out");
+    }
+    else if (parameterBlockType->As<GLSLShaderStorageBufferType>())
+    {
+        Emit(context, "buffer");
+    }
+    else
+    {
+        assert(!"unexpected");
+        Emit(context, "uniform");
+    }
+
+    if( auto reflectionNameModifier = varDecl->FindModifier<ParameterBlockReflectionName>() )
+    {
+        Emit(context, " ");
+        emitName(context, reflectionNameModifier->nameToken.Content);
+    }
+
+    Emit(context, "\n{\n");
+    if (auto structRef = declRefType->declRef.As<StructDeclRef>())
+    {
+        for (auto field : structRef.GetMembersOfType<FieldDeclRef>())
+        {
+            RefPtr<VarLayout> fieldLayout;
+            structTypeLayout->mapVarToLayout.TryGetValue(field.GetDecl(), fieldLayout);
+            assert(fieldLayout);
+
+            // TODO(tfoley): We may want to emit *some* of these,
+            // some of the time...
+//            emitGLSLLayoutQualifiers(context, fieldLayout);
+
+            EmitVarDeclCommon(context, field);
+
+            Emit(context, ";\n");
+        }
+    }
+    Emit(context, "}");
+
+    if( varDecl->Name.Type != TokenType::Unknown )
+    {
+        Emit(context, " ");
+        emitName(context, varDecl->Name.Content);
+    }
+
+    Emit(context, ";\n");
+}
+
+static void emitParameterBlockDecl(
+    EmitContext*				context,
+    RefPtr<VarDeclBase>			varDecl,
+    RefPtr<ParameterBlockType>  parameterBlockType,
+    RefPtr<VarLayout>           layout)
+{
+    switch(context->target)
+    {
+    case CodeGenTarget::HLSL:
+        emitHLSLParameterBlockDecl(context, varDecl, parameterBlockType, layout);
+        break;
+
+    case CodeGenTarget::GLSL:
+        emitGLSLParameterBlockDecl(context, varDecl, parameterBlockType, layout);
+        break;
+
+    default:
+        assert(!"unexpected");
+        break;
+    }
+}
+
+static void EmitVarDecl(EmitContext* context, RefPtr<VarDeclBase> decl, RefPtr<VarLayout> layout)
+{
+    // As a special case, a variable using a parameter block type
+    // will be translated into a declaration using the more primitive
+    // language syntax.
+    //
+    // TODO(tfoley): Be sure to unwrap arrays here, in the GLSL case.
+    //
+    // TODO(tfoley): Detect cases where we need to fall back to
+    // ordinary variable declaration syntax in HLSL.
+    //
+    // 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>())
+    {
+        emitParameterBlockDecl(context, decl, parameterBlockType, layout);
+        return;
+    }
+
+    emitGLSLLayoutQualifiers(context, layout);
+
+    EmitVarDeclCommon(context, decl);
+
+    emitHLSLRegisterSemantics(context, layout);
+
+    Emit(context, ";\n");
+}
+
+static void EmitParamDecl(EmitContext* context, RefPtr<ParameterSyntaxNode> decl)
+{
+    EmitVarDeclCommon(context, decl);
+}
+
+static void EmitFuncDecl(EmitContext* context, RefPtr<FunctionSyntaxNode> decl)
+{
+    EmitModifiers(context, decl);
+
+    // TODO: if a function returns an array type, or something similar that
+    // isn't allowed by declarator syntax and/or language rules, we could
+    // hypothetically wrap things in a `typedef` and work around it.
+
+    EmitType(context, decl->ReturnType, decl->Name.Content);
+
+    Emit(context, "(");
+    bool first = true;
+    for (auto paramDecl : decl->GetMembersOfType<ParameterSyntaxNode>())
+    {
+        if (!first) Emit(context, ", ");
+        EmitParamDecl(context, paramDecl);
+        first = false;
+    }
+    Emit(context, ")");
+
+    EmitSemantics(context, decl);
+
+    if (auto bodyStmt = decl->Body)
+    {
+        EmitBlockStmt(context, bodyStmt);
+    }
+    else
+    {
+        Emit(context, ";\n");
+    }
+}
+
+static void emitGLSLPreprocessorDirectives(
+    EmitContext*                context,
+    RefPtr<ProgramSyntaxNode>   program)
+{
+    switch(context->target)
+    {
+    // Don't emit this stuff unless we are targetting GLSL
+    default:
+        return;
+
+    case CodeGenTarget::GLSL:
+        break;
+    }
+
+    if( auto versionDirective = program->FindModifier<GLSLVersionDirective>() )
+    {
+        // TODO(tfoley): Emit an appropriate `#line` directive...
+
+        Emit(context, "#version ");
+        emit(context, versionDirective->versionNumberToken.Content);
+        if(versionDirective->glslProfileToken.Type != TokenType::Unknown)
+        {
+            Emit(context, " ");
+            emit(context, versionDirective->glslProfileToken.Content);
+        }
+        Emit(context, "\n");
+    }
+    else
+    {
+        // No explicit version was given (probably because we are cross-compiling).
+        //
+        // We need to pick an appropriate version, ideally based on the features
+        // that the shader ends up using.
+        //
+        // For now we just fall back to a reasonably recent version.
+
+        Emit(context, "#version 420\n");
+    }
+
+    // TODO: when cross-compiling we may need to output additional `#extension` directives
+    // based on the features that we have used.
+
+    for( auto extensionDirective :  program->GetModifiersOfType<GLSLExtensionDirective>() )
+    {
+        // TODO(tfoley): Emit an appropriate `#line` directive...
+
+        Emit(context, "#extension ");
+        emit(context, extensionDirective->extensionNameToken.Content);
+        Emit(context, " : ");
+        emit(context, extensionDirective->dispositionToken.Content);
+        Emit(context, "\n");
+    }
+
+    // TODO: handle other cases...
+}
+
+static void EmitProgram(
+    EmitContext*                context,
+    RefPtr<ProgramSyntaxNode>   program,
+    RefPtr<ProgramLayout>       programLayout)
+{
+    // There may be global-scope modifiers that we should emit now
+    emitGLSLPreprocessorDirectives(context, program);
+
+    switch(context->target)
+    {
+    case CodeGenTarget::GLSL:
+        {
+            // TODO(tfoley): Need a plan for how to enable/disable these as needed...
+//            Emit(context, "#extension GL_GOOGLE_cpp_style_line_directive : require\n");
+        }
+        break;
+
+    default:
+        break;
+    }
+
+
+    // Layout information for the global scope is either an ordinary
+    // `struct` in the common case, or a constant buffer in the case
+    // where there were global-scope uniforms.
+    auto globalScopeLayout = programLayout->globalScopeLayout;
+    if( auto globalStructLayout = globalScopeLayout.As<StructTypeLayout>() )
+    {
+        // The `struct` case is easy enough to handle: we just
+        // emit all the declarations directly, using their layout
+        // information as a guideline.
+        EmitDeclsInContainerUsingLayout(context, program, globalStructLayout);
+    }
+    else if(auto globalConstantBufferLayout = globalScopeLayout.As<ParameterBlockTypeLayout>())
+    {
+        // TODO: the `cbuffer` case really needs to be emitted very
+        // carefully, but that is beyond the scope of what a simple rewriter
+        // can easily do (without semantic analysis, etc.).
+        //
+        // The crux of the problem is that we need to collect all the
+        // global-scope uniforms (but not declarations that don't involve
+        // uniform storage...) and put them in a single `cbuffer` declaration,
+        // so that we can give it an explicit location. The fields in that
+        // declaration might use various type declarations, so we'd really
+        // need to emit all the type declarations first, and that involves
+        // some large scale reorderings.
+        //
+        // For now we will punt and just emit the declarations normally,
+        // and hope that the global-scope block (`$Globals`) gets auto-assigned
+        // the same location that we manually asigned it.
+
+        auto elementTypeLayout = globalConstantBufferLayout->elementTypeLayout;
+        auto elementTypeStructLayout = elementTypeLayout.As<StructTypeLayout>();
+
+        // We expect all constant buffers to contain `struct` types for now
+        assert(elementTypeStructLayout);
+
+        EmitDeclsInContainerUsingLayout(
+            context,
+            program,
+            elementTypeStructLayout);
+    }
+    else
+    {
+        assert(!"unexpected");
+    }
+}
+
+static void EmitDeclImpl(EmitContext* context, RefPtr<Decl> decl, RefPtr<VarLayout> layout)
+{
+    // Don't emit code for declarations that came from the stdlib.
+    //
+    // TODO(tfoley): We probably need to relax this eventually,
+    // since different targets might have different sets of builtins.
+    if (decl->HasModifier<FromStdLibModifier>())
+        return;
+
+    if (auto typeDefDecl = decl.As<TypeDefDecl>())
+    {
+        EmitTypeDefDecl(context, typeDefDecl);
+        return;
+    }
+    else if (auto structDecl = decl.As<StructSyntaxNode>())
+    {
+        EmitStructDecl(context, structDecl);
+        return;
+    }
+    else if (auto varDecl = decl.As<VarDeclBase>())
+    {
+        EmitVarDecl(context, varDecl, layout);
+        return;
+    }
+    else if (auto funcDecl = decl.As<FunctionSyntaxNode>())
+    {
+        EmitFuncDecl(context, funcDecl);
+        return;
+    }
+    else if (auto genericDecl = decl.As<GenericDecl>())
+    {
+        // Don't emit generic decls directly; we will only
+        // ever emit particular instantiations of them.
+        return;
+    }
+	else if (auto classDecl = decl.As<ClassSyntaxNode>())
+	{
+		return;
+	}
+    else if( auto emptyDecl = decl.As<EmptyDecl>() )
+    {
+        EmitModifiers(context, emptyDecl);
+        Emit(context, ";\n");
+        return;
+    }
+    throw "unimplemented";
+}
+
+static void EmitDecl(EmitContext* context, RefPtr<Decl> decl)
+{
+    EmitDeclImpl(context, decl, nullptr);
+}
+
+static void EmitDeclUsingLayout(EmitContext* context, RefPtr<Decl> decl, RefPtr<VarLayout> layout)
+{
+    EmitDeclImpl(context, decl, layout);
+}
+
+static void EmitDecl(EmitContext* context, RefPtr<DeclBase> declBase)
+{
+    if( auto decl = declBase.As<Decl>() )
+    {
+        EmitDecl(context, decl);
+    }
+    else if(auto declGroup = declBase.As<DeclGroup>())
+    {
+        for(auto d : declGroup->decls)
+            EmitDecl(context, d);
+    }
+    else
+    {
+        throw "unimplemented";
+    }
+}
+
+static void registerReservedWord(
+    EmitContext*    context,
+    String const&   name)
+{
+    context->reservedWords.Add(name, name);
+}
+
+static void registerReservedWords(
+    EmitContext*    context)
+{
+#define WORD(NAME) registerReservedWord(context, #NAME)
+
+    switch (context->target)
+    {
+    case CodeGenTarget::GLSL:
+        WORD(attribute);
+        WORD(const);
+        WORD(uniform);
+        WORD(varying);
+        WORD(buffer);
+
+        WORD(shared);
+        WORD(coherent);
+        WORD(volatile);
+        WORD(restrict);
+        WORD(readonly);
+        WORD(writeonly);
+        WORD(atomic_unit);
+        WORD(layout);
+        WORD(centroid);
+        WORD(flat);
+        WORD(smooth);
+        WORD(noperspective);
+        WORD(patch);
+        WORD(sample);
+        WORD(break);
+        WORD(continue);
+        WORD(do);
+        WORD(for);
+        WORD(while);
+        WORD(switch);
+        WORD(case);
+        WORD(default);
+        WORD(if);
+        WORD(else);
+        WORD(subroutine);
+        WORD(in);
+        WORD(out);
+        WORD(inout);
+        WORD(float);
+        WORD(double);
+        WORD(int);
+        WORD(void);
+        WORD(bool);
+        WORD(true);
+        WORD(false);
+        WORD(invariant);
+        WORD(precise);
+        WORD(discard);
+        WORD(return);
+
+        WORD(lowp);
+        WORD(mediump);
+        WORD(highp);
+        WORD(precision);
+        WORD(struct);
+        WORD(uint);
+
+        WORD(common);
+        WORD(partition);
+        WORD(active);
+        WORD(asm);
+        WORD(class);
+        WORD(union);
+        WORD(enum);
+        WORD(typedef);
+        WORD(template);
+        WORD(this);
+        WORD(resource);
+
+        WORD(goto);
+        WORD(inline);
+        WORD(noinline);
+        WORD(public);
+        WORD(static);
+        WORD(extern);
+        WORD(external);
+        WORD(interface);
+        WORD(long);
+        WORD(short);
+        WORD(half);
+        WORD(fixed);
+        WORD(unsigned);
+        WORD(superp);
+        WORD(input);
+        WORD(output);
+        WORD(filter);
+        WORD(sizeof);
+        WORD(cast);
+        WORD(namespace);
+        WORD(using);
+
+#define CASE(NAME) \
+    WORD(NAME ## 2); WORD(NAME ## 3); WORD(NAME ## 4)
+
+        CASE(mat);
+        CASE(dmat);
+        CASE(mat2x);
+        CASE(mat3x);
+        CASE(mat4x);
+        CASE(dmat2x);
+        CASE(dmat3x);
+        CASE(dmat4x);
+        CASE(vec);
+        CASE(ivec);
+        CASE(bvec);
+        CASE(dvec);
+        CASE(uvec);
+        CASE(hvec);
+        CASE(fvec);
+
+#undef CASE
+
+#define CASE(NAME)          \
+    WORD(NAME ## 1D);       \
+    WORD(NAME ## 2D);       \
+    WORD(NAME ## 3D);       \
+    WORD(NAME ## Cube);     \
+    WORD(NAME ## 1DArray);  \
+    WORD(NAME ## 2DArray);  \
+    WORD(NAME ## 3DArray);  \
+    WORD(NAME ## CubeArray);\
+    WORD(NAME ## 2DMS);     \
+    WORD(NAME ## 2DMSArray) \
+    /* end */
+
+#define CASE2(NAME)     \
+    CASE(NAME);         \
+    CASE(i ## NAME);    \
+    CASE(u ## NAME)     \
+    /* end */
+
+    CASE2(sampler);
+    CASE2(image);
+    CASE2(texture);
+
+#undef CASE2
+#undef CASE
+        break;
+
+    default:
+        break;
+    }
+}
+
+String emitProgram(
+    ProgramSyntaxNode*  program,
+    ProgramLayout*      programLayout,
+    CodeGenTarget       target)
+{
+    // TODO(tfoley): only emit symbols on-demand, as needed by a particular entry point
+
+    EmitContext context;
+    context.target = target;
+
+    registerReservedWords(&context);
+
+    EmitProgram(&context, program, programLayout);
+
+    String code = context.sb.ProduceString();
+
+    return code;
+
+#if 0
+    // HACK(tfoley): Invoke the D3D HLSL compiler on the result, to validate it
+
+#ifdef _WIN32
+    {
+        HMODULE d3dCompiler = LoadLibraryA("d3dcompiler_47");
+        assert(d3dCompiler);
+
+        pD3DCompile D3DCompile_ = (pD3DCompile)GetProcAddress(d3dCompiler, "D3DCompile");
+        assert(D3DCompile_);
+
+        ID3DBlob* codeBlob;
+        ID3DBlob* diagnosticsBlob;
+        HRESULT hr = D3DCompile_(
+            code.begin(),
+            code.Length(),
+            "slang",
+            nullptr,
+            nullptr,
+            "main",
+            "ps_5_0",
+            0,
+            0,
+            &codeBlob,
+            &diagnosticsBlob);
+        if (codeBlob) codeBlob->Release();
+        if (diagnosticsBlob)
+        {
+            String diagnostics = (char const*) diagnosticsBlob->GetBufferPointer();
+            fprintf(stderr, "%s", diagnostics.begin());
+            OutputDebugStringA(diagnostics.begin());
+            diagnosticsBlob->Release();
+        }
+        if (FAILED(hr))
+        {
+            int f = 9;
+        }
+    }
+
+    #include <d3dcompiler.h>
+#endif
+#endif
+
+}
+
+
+}} // Slang::Compiler