in-progress work

19 files changed, 434 insertions, 522 deletions

diff --git a/source/core/core.natvis b/source/core/core.natvis
index 3d9ac702e..91fdbb49b 100644
--- a/source/core/core.natvis
+++ b/source/core/core.natvis
@@ -54,7 +54,7 @@
     </Expand>
 </Type>
 
-<Type Name="Slang::RefPtrImpl&lt;*,*,*&gt;">
+<Type Name="Slang::RefPtr&lt;*&gt;">
     <SmartPointer Usage="Minimal">pointer</SmartPointer>
     <DisplayString Condition="pointer == 0">empty</DisplayString>
     <DisplayString Condition="pointer != 0">RefPtr {*pointer}</DisplayString>
diff --git a/source/slang/bytecode.cpp b/source/slang/bytecode.cpp
index f1b23849d..ee055a01f 100644
--- a/source/slang/bytecode.cpp
+++ b/source/slang/bytecode.cpp
@@ -77,7 +77,6 @@ struct BytecodeGenerationPtr
 
     BytecodeGenerationPtr<T> operator+(Int index) const
     {
-        UInt size = sizeof(T);
         Int delta = index * sizeof(T);
         UInt newOffset = offset + delta;
         return BytecodeGenerationPtr<T>(
@@ -157,7 +156,7 @@ BCPtr<void>::RawVal allocateRaw(
     for(size_t ii = currentOffset; ii < endOffset; ++ii)
         context->shared->bytecode.Add(0);
 
-    return beginOffset;
+    return (BCPtr<void>::RawVal)beginOffset;
 }
 
 template<typename T>
@@ -196,7 +195,7 @@ void encodeUInt(
 {
     if( value < 128 )
     {
-        encodeUInt8(context, value);
+        encodeUInt8(context, (uint8_t)value);
         return;
     }
 
@@ -256,9 +255,8 @@ BCConst getGlobalValue(
             UInt constID = context->shared->constants.Count();
             context->shared->constants.Add(value);
 
-            BCConst bcConst;
             bcConst.flavor = kBCConstFlavor_Constant;
-            bcConst.id = constID;
+            bcConst.id = (uint32_t)constID;
 
             context->shared->mapValueToGlobal.Add(value, bcConst);
 
@@ -270,10 +268,10 @@ BCConst getGlobalValue(
         break;
     }
 
+    bcConst.flavor = (uint32_t) -1;
+    bcConst.id = (uint32_t)-9999;
     SLANG_UNEXPECTED("no ID for inst");
-    bcConst.flavor = (BCConstFlavor) -1;
-    bcConst.id = -9999;
-    return bcConst;
+    //return bcConst;
 }
 
 Int getLocalID(
@@ -348,7 +346,6 @@ void generateBytecodeForInst(
             //
 
             auto argCount = inst->getArgCount();
-            auto type = inst->getType();
             encodeUInt(context, inst->op);
             encodeOperand(context, inst->getType());
             encodeUInt(context, argCount);
@@ -400,9 +397,9 @@ void generateBytecodeForInst(
             unsigned char buffer[size];
             memcpy(buffer, &ii->u.floatVal, sizeof(buffer));
 
-            for(UInt ii = 0; ii < size; ++ii)
+            for(UInt i = 0; i < size; ++i)
             {
-                encodeUInt8(context, buffer[ii]);
+                encodeUInt8(context, buffer[i]);
             }
 
             // destination:
@@ -479,7 +476,7 @@ BytecodeGenerationPtr<BCType> emitBCType(
     auto bcArgs = (bcType + 1).bitCast<BCPtr<uint8_t>>();
 
     bcType->op = op;
-    bcType->argCount = argCount;
+    bcType->argCount = (uint32_t)argCount;
 
     for(UInt aa = 0; aa < argCount; ++aa)
     {
@@ -489,7 +486,7 @@ BytecodeGenerationPtr<BCType> emitBCType(
     UInt id = context->shared->bcTypes.Count();
     context->shared->mapTypeToID.Add(type, id);
     context->shared->bcTypes.Add(bcType);
-    bcType->id = id;
+    bcType->id = (uint32_t)id;
 
     return bcType;
 }
@@ -577,7 +574,6 @@ BytecodeGenerationPtr<BCType> emitBCTypeImpl(
 
 
     SLANG_UNEXPECTED("unimplemented");
-    return BytecodeGenerationPtr<BCType>();
 }
 
 BytecodeGenerationPtr<BCType> emitBCType(
@@ -703,7 +699,7 @@ BytecodeGenerationPtr<BCSymbol> generateBytecodeSymbolForInst(
             // Allocate the array of block objects to be stored in the
             // bytecode file.
             auto bcBlocks = allocateArray<BCBlock>(context, blockCount);
-            bcFunc->blockCount = blockCount;
+            bcFunc->blockCount = (uint32_t)blockCount;
             bcFunc->blocks = bcBlocks;
 
             // Now loop through the blocks again, and allocate the storage
@@ -750,7 +746,7 @@ BytecodeGenerationPtr<BCSymbol> generateBytecodeSymbolForInst(
                     }
                 }
 
-                bcBlocks[blockID].paramCount = paramCount;
+                bcBlocks[blockID].paramCount = (uint32_t)paramCount;
             }
 
             // Okay, we've counted how many registers we need for each block,
@@ -758,7 +754,7 @@ BytecodeGenerationPtr<BCSymbol> generateBytecodeSymbolForInst(
             UInt regCount = regCounter;
             auto bcRegs = allocateArray<BCReg>(context, regCount);
 
-            bcFunc->regCount = regCount;
+            bcFunc->regCount = (uint32_t)regCount;
             bcFunc->regs = bcRegs;
 
             // Now we will loop over things again to fill in the information
@@ -786,7 +782,7 @@ BytecodeGenerationPtr<BCSymbol> generateBytecodeSymbolForInst(
 #if 0
                     bcRegs[localID].name = tryGenerateNameForSymbol(context, pp);
 #endif
-                    bcRegs[localID].previousVarIndexPlusOne = localID;
+                    bcRegs[localID].previousVarIndexPlusOne = (uint32_t)localID;
                     bcRegs[localID].typeID = getTypeIDForGlobalSymbol(context, pp);
                 }
 
@@ -808,7 +804,7 @@ BytecodeGenerationPtr<BCSymbol> generateBytecodeSymbolForInst(
 #if 0
                             bcRegs[localID].name = tryGenerateNameForSymbol(context, ii);
 #endif
-                            bcRegs[localID].previousVarIndexPlusOne = localID;
+                            bcRegs[localID].previousVarIndexPlusOne = (uint32_t)localID;
                             bcRegs[localID].typeID = getTypeIDForGlobalSymbol(context, ii);
                         }
                         break;
@@ -828,11 +824,11 @@ BytecodeGenerationPtr<BCSymbol> generateBytecodeSymbolForInst(
 #if 0
                             bcRegs[localID].name = tryGenerateNameForSymbol(context, ii);
 #endif
-                            bcRegs[localID].previousVarIndexPlusOne = localID;
+                            bcRegs[localID].previousVarIndexPlusOne = (uint32_t)localID;
                             bcRegs[localID].typeID = getTypeIDForGlobalSymbol(context, ii);
 
                             bcRegs[localID+1].op = ii->op;
-                            bcRegs[localID+1].previousVarIndexPlusOne = localID+1;
+                            bcRegs[localID+1].previousVarIndexPlusOne = (uint32_t)localID+1;
                             bcRegs[localID+1].typeID = getTypeID(context,
                                 (ii->getType()->As<PtrType>())->getValueType());
                         }
@@ -840,7 +836,7 @@ BytecodeGenerationPtr<BCSymbol> generateBytecodeSymbolForInst(
                     }
                 }
             }
-            assert(regCounter == regCount);
+            assert((UInt)regCounter == regCount);
 
             // Now that we've allocated our blocks and our registers
             // we can go through the actual process of emitting instructions. Hooray!
@@ -851,7 +847,7 @@ BytecodeGenerationPtr<BCSymbol> generateBytecodeSymbolForInst(
             List<UInt> blockOffsets;
             for( auto bb = irFunc->getFirstBlock(); bb; bb = bb->getNextBlock() )
             {
-                UInt blockID = blockCounter++;
+                blockCounter++;
 
                 // Get local bytecode offset for current block.
                 UInt blockOffset = subContext->currentBytecode.Count();
@@ -903,7 +899,7 @@ BytecodeGenerationPtr<BCSymbol> generateBytecodeSymbolForInst(
             UInt constCount = subContext->remappedGlobalSymbols.Count();
             auto bcConsts = allocateArray<BCConst>(context, constCount);
 
-            bcFunc->constCount = constCount;
+            bcFunc->constCount = (uint32_t)constCount;
             bcFunc->consts = bcConsts;
 
             for( UInt cc = 0; cc < constCount; ++cc )
@@ -969,7 +965,7 @@ BytecodeGenerationPtr<BCModule> generateBytecodeForModule(
         // Ensure that local code inside functions can see these symbols
         BCConst bcConst;
         bcConst.flavor = kBCConstFlavor_GlobalSymbol;
-        bcConst.id = globalID;
+        bcConst.id = (uint32_t)globalID;
         context->shared->mapValueToGlobal.Add(gv, bcConst);
 
         // In the global scope, global IDs are also the local IDs
@@ -978,7 +974,7 @@ BytecodeGenerationPtr<BCModule> generateBytecodeForModule(
 
     auto bcSymbols = allocateArray<BCPtr<BCSymbol>>(context, symbolCount);
 
-    bcModule->symbolCount = symbolCount;
+    bcModule->symbolCount = (uint32_t)symbolCount;
     bcModule->symbols = bcSymbols;
 
     for( auto gv = irModule->getFirstGlobalValue(); gv; gv = gv->getNextValue() )
@@ -998,7 +994,7 @@ BytecodeGenerationPtr<BCModule> generateBytecodeForModule(
     // At this point we should have identified all the literals we need:
     UInt constantCount = context->shared->constants.Count();
     auto bcConstants = allocateArray<BCConstant>(context, constantCount);
-    bcModule->constantCount = constantCount;
+    bcModule->constantCount = (uint32_t)constantCount;
     bcModule->constants = bcConstants;
 
     for(UInt cc = 0; cc < constantCount; ++cc)
@@ -1026,7 +1022,7 @@ BytecodeGenerationPtr<BCModule> generateBytecodeForModule(
     // At this point we should have collected all the types we need:
     UInt typeCount = context->shared->bcTypes.Count();
     auto bcTypes = allocateArray<BCPtr<BCType>>(context, typeCount);
-    bcModule->typeCount = typeCount;
+    bcModule->typeCount = (uint32_t)typeCount;
     bcModule->types = bcTypes;
 
     for(UInt tt = 0; tt < typeCount; ++tt)
@@ -1055,8 +1051,6 @@ void generateBytecodeContainer(
     // TODO: Need to dump BC representation of compiled kernel codes
     // for each specified code-generation target.
 
-    UInt translationUnitCount = compileReq->translationUnits.Count();
-
     List<BytecodeGenerationPtr<BCModule>> bcModulesList;
     for (auto translationUnitReq : compileReq->translationUnits)
     {
@@ -1065,7 +1059,7 @@ void generateBytecodeContainer(
     }
 
     UInt bcModuleCount = bcModulesList.Count();
-    header->moduleCount = bcModuleCount;
+    header->moduleCount = (uint32_t)bcModuleCount;
 
     auto bcModules = allocateArray<BCPtr<BCModule>>(context, bcModuleCount);
     header->modules = bcModules;
diff --git a/source/slang/bytecode.h b/source/slang/bytecode.h
index 75b9f15cd..f1ad52c32 100644
--- a/source/slang/bytecode.h
+++ b/source/slang/bytecode.h
@@ -56,7 +56,7 @@ struct BCPtr
     {
         if (ptr)
         {
-            rawVal = (char*)ptr - (char*)this;
+            rawVal = (RawVal)((char*)ptr - (char*)this);
         }
         else
         {
diff --git a/source/slang/check.cpp b/source/slang/check.cpp
index dc4e48545..137b1c451 100644
--- a/source/slang/check.cpp
+++ b/source/slang/check.cpp
@@ -148,15 +148,13 @@ namespace Slang
             if (baseExpr)
             {
                 RefPtr<Expr> expr;
-                
+
                 if (baseExpr->type->As<TypeType>())
                 {
                     auto sexpr = new StaticMemberExpr();
                     sexpr->loc = loc;
                     sexpr->BaseExpression = baseExpr;
                     sexpr->name = declRef.GetName();
-                    sexpr->type = GetTypeForDeclRef(declRef);
-                    sexpr->declRef = declRef;
                     expr = sexpr;
                 }
                 else
@@ -165,54 +163,24 @@ namespace Slang
                     sexpr->loc = loc;
                     sexpr->BaseExpression = baseExpr;
                     sexpr->name = declRef.GetName();
-                    sexpr->type = GetTypeForDeclRef(declRef);
                     sexpr->declRef = declRef;
                     expr = sexpr;
                 }
-                if (auto constraintType = expr->type->As<GenericConstraintDeclRefType>())
+                if (auto assocTypeDecl = declRef.As<AssocTypeDecl>())
                 {
-                    if (baseExpr->type->As<TypeType>())
-                        constraintType->subType = baseExpr->type->As<TypeType>()->type;
-                    else
-                        constraintType->subType = baseExpr->type;
-
+                    RefPtr<ThisTypeSubstitution> subst = new ThisTypeSubstitution();
+                    subst->sourceType = baseExpr->type.type;
+                    if (auto typeType = subst->sourceType.As<TypeType>())
+                        subst->sourceType = typeType->type;
+                    expr->type = GetTypeForDeclRef(DeclRef<AssocTypeDecl>(assocTypeDecl.getDecl(), subst));
                 }
-                
-                if (auto genConstraintType = baseExpr->type->As<GenericConstraintDeclRefType>())
+                else if (auto constraintDecl = declRef.As<GenericTypeConstraintDecl>())
                 {
-                    if (auto funcDeclRef = declRef.As<CallableDecl>())
-                    {
-                        // if this is call expression, propagate the source associated type to the result type
-                        auto funcType = expr->type->As<FuncType>();
-                        if (auto assocRsType = funcType->resultType.As<AssocTypeDeclRefType>())
-                        {
-                            RefPtr<FuncType> newFuncType = new FuncType();
-                            newFuncType->paramTypes = funcType->paramTypes;
-                            RefPtr<AssocTypeDeclRefType> newRsType = new AssocTypeDeclRefType();
-                            newRsType->declRef = assocRsType->declRef;
-                            newRsType->sourceType = genConstraintType->subType;
-                            newRsType->setSession(getSession());
-                            newFuncType->resultType = newRsType;
-                            newFuncType->setSession(funcType->getSession());
-                            expr->type = QualType(newFuncType);
-                        }
-                    }
-                    else if (auto assocTypeDeclRef = declRef.As<AssocTypeDecl>())
-                    {
-                        auto assocTypeDeclType = new AssocTypeDeclRefType();
-                        assocTypeDeclType->declRef = assocTypeDeclRef;
-                        assocTypeDeclType->sourceType = genConstraintType->subType;
-                        assocTypeDeclType->setSession(getSession());
-                        expr->type = QualType(getTypeType(assocTypeDeclType));
-                    }
+                    expr->type = baseExpr->type;
                 }
-                else if (auto assocTypeDeclRef = declRef.As<AssocTypeDecl>())
+                else
                 {
-                    auto assocTypeDeclType = new AssocTypeDeclRefType();
-                    assocTypeDeclType->declRef = assocTypeDeclRef;
-                    assocTypeDeclType->sourceType = baseExpr->type;
-                    assocTypeDeclType->setSession(getSession());
-                    expr->type = QualType(getTypeType(assocTypeDeclType));
+                    expr->type = GetTypeForDeclRef(declRef);
                 }
                 return expr;
             }
@@ -449,7 +417,7 @@ namespace Slang
             DeclRef<GenericDecl>						genericDeclRef,
             List<RefPtr<Expr>> const&	args)
         {
-            RefPtr<Substitutions> subst = new Substitutions();
+            RefPtr<GenericSubstitution> subst = new GenericSubstitution();
             subst->genericDecl = genericDeclRef.getDecl();
             subst->outer = genericDeclRef.substitutions;
 
@@ -2097,10 +2065,10 @@ namespace Slang
             return true;
         }
 
-        RefPtr<Substitutions> createDummySubstitutions(
+        RefPtr<GenericSubstitution> createDummySubstitutions(
             GenericDecl* genericDecl)
         {
-            RefPtr<Substitutions> subst = new Substitutions();
+            RefPtr<GenericSubstitution> subst = new GenericSubstitution();
             subst->genericDecl = genericDecl;
             for (auto dd : genericDecl->Members)
             {
@@ -3115,7 +3083,7 @@ namespace Slang
                 session, "Vector").As<GenericDecl>();
             auto vectorTypeDecl = vectorGenericDecl->inner;
                
-            auto substitutions = new Substitutions();
+            auto substitutions = new GenericSubstitution();
             substitutions->genericDecl = vectorGenericDecl.Ptr();
             substitutions->args.Add(elementType);
             substitutions->args.Add(elementCount);
@@ -3447,7 +3415,7 @@ namespace Slang
                 // to `interfaceDeclRef`.
                 //
                 SLANG_UNEXPECTED("reflexive type witness");
-                return nullptr;
+                //return nullptr;
             }
 
             auto breadcrumbs = inBreadcrumbs;
@@ -3462,7 +3430,7 @@ namespace Slang
                 // because `A : B` and `B : C` then `A : C`
                 //
                 SLANG_UNEXPECTED("transitive type witness");
-                return nullptr;
+                //return nullptr;
             }
 
             // Simple case: we have a single declaration
@@ -3815,7 +3783,7 @@ namespace Slang
 
             // Consruct a reference to the extension with our constraint variables
             // as the 
-            RefPtr<Substitutions> solvedSubst = new Substitutions();
+            RefPtr<GenericSubstitution> solvedSubst = new GenericSubstitution();
             solvedSubst->genericDecl = genericDeclRef.getDecl();
             solvedSubst->outer = genericDeclRef.substitutions;
             solvedSubst->args = args;
@@ -4084,8 +4052,9 @@ namespace Slang
             // We will go ahead and hang onto the arguments that we've
             // already checked, since downstream validation might need
             // them.
-            candidate.subst = new Substitutions();
-            auto& checkedArgs = candidate.subst->args;
+            auto genSubst = new GenericSubstitution();
+            candidate.subst = genSubst;
+            auto& checkedArgs = genSubst->args;
 
             int aa = 0;
             for (auto memberRef : getMembers(genericDeclRef))
@@ -4202,7 +4171,7 @@ namespace Slang
         // Create a witness that attests to the fact that `type`
         // is equal to itself.
         RefPtr<Val> createTypeEqualityWitness(
-            Type*   type)
+            Type*   /*type*/)
         {
             SLANG_UNEXPECTED("unimplemented");
         }
@@ -4258,7 +4227,7 @@ namespace Slang
             // We should have the existing arguments to the generic
             // handy, so that we can construct a substitution list.
 
-            RefPtr<Substitutions> subst = candidate.subst;
+            RefPtr<GenericSubstitution> subst = candidate.subst.As<GenericSubstitution>();
             assert(subst);
 
             subst->genericDecl = genericDeclRef.getDecl();
@@ -4325,7 +4294,7 @@ namespace Slang
         RefPtr<Expr> createGenericDeclRef(
             RefPtr<Expr>            baseExpr,
             RefPtr<Expr>            originalExpr,
-            RefPtr<Substitutions>   subst)
+            RefPtr<GenericSubstitution>   subst)
         {
             auto baseDeclRefExpr = baseExpr.As<DeclRefExpr>();
             if (!baseDeclRefExpr)
@@ -4437,7 +4406,7 @@ namespace Slang
                     return createGenericDeclRef(
                         baseExpr,
                         context.originalExpr,
-                        candidate.subst);
+                        candidate.subst.As<GenericSubstitution>());
                     break;
 
                 default:
@@ -4734,22 +4703,23 @@ namespace Slang
             // They must both be NULL or non-NULL
             if (!fst || !snd)
                 return fst == snd;
-
+            auto fstGen = fst.As<GenericSubstitution>();
+            auto sndGen = snd.As<GenericSubstitution>();
             // They must be specializing the same generic
-            if (fst->genericDecl != snd->genericDecl)
+            if (fstGen->genericDecl != sndGen->genericDecl)
                 return false;
 
             // Their arguments must unify
-            SLANG_RELEASE_ASSERT(fst->args.Count() == snd->args.Count());
-            UInt argCount = fst->args.Count();
+            SLANG_RELEASE_ASSERT(fstGen->args.Count() == sndGen->args.Count());
+            UInt argCount = fstGen->args.Count();
             for (UInt aa = 0; aa < argCount; ++aa)
             {
-                if (!TryUnifyVals(constraints, fst->args[aa], snd->args[aa]))
+                if (!TryUnifyVals(constraints, fstGen->args[aa], sndGen->args[aa]))
                     return false;
             }
 
             // Their "base" specializations must unify
-            if (!TryUnifySubstitutions(constraints, fst->outer, snd->outer))
+            if (!TryUnifySubstitutions(constraints, fstGen->outer, sndGen->outer))
                 return false;
 
             return true;
@@ -5304,11 +5274,12 @@ namespace Slang
             if( parentGenericDeclRef )
             {
                 SLANG_RELEASE_ASSERT(declRef.substitutions);
-                SLANG_RELEASE_ASSERT(declRef.substitutions->genericDecl == parentGenericDeclRef.getDecl());
+                auto genSubst = declRef.substitutions.As<GenericSubstitution>();
+                SLANG_RELEASE_ASSERT(genSubst->genericDecl == parentGenericDeclRef.getDecl());
 
                 sb << "<";
                 bool first = true;
-                for(auto arg : declRef.substitutions->args)
+                for(auto arg : genSubst->args)
                 {
                     if(!first) sb << ", ";
                     formatVal(sb, arg);
@@ -6069,7 +6040,7 @@ namespace Slang
         RefPtr<Expr> visitStaticMemberExpr(StaticMemberExpr* expr)
         {
             SLANG_UNEXPECTED("should not occur in unchecked AST");
-            return expr;
+            //return expr;
         }
 
         RefPtr<Expr> lookupResultFailure(
@@ -6495,26 +6466,11 @@ namespace Slang
             *outTypeResult = type;
             return QualType(getTypeType(type));
         }
-        else if (auto constraintDeclRef = declRef.As<GenericTypeConstraintDecl>())
-        {
-            // When we access a constraint or an inheritance decl (as a member),
-            // we are conceptually performing a "cast" to the given super-type,
-            // with the declaration showing that such a cast is legal.
-            auto type = new GenericConstraintDeclRefType(session, GetSub(constraintDeclRef), GetSup(constraintDeclRef));
-            return QualType(type);
-        }
         else if (auto funcDeclRef = declRef.As<CallableDecl>())
         {
             auto type = getFuncType(session, funcDeclRef);
             return QualType(type);
         }
-        else if (auto assocTypeDeclRef = declRef.As<AssocTypeDecl>())
-        {
-            auto type = new AssocTypeDeclRefType(assocTypeDeclRef);
-            type->setSession(session);
-            *outTypeResult = type;
-            return QualType(getTypeType(type));
-        }
         if( sink )
         {
             sink->diagnose(declRef, Diagnostics::unimplemented, "cannot form reference to this kind of declaration");
@@ -6558,7 +6514,7 @@ namespace Slang
             if(decl != genericDecl->inner)
                 return parentSubst;
 
-            RefPtr<Substitutions> subst = new Substitutions();
+            RefPtr<GenericSubstitution> subst = new GenericSubstitution();
             subst->genericDecl = genericDecl;
             subst->outer = parentSubst;
 
diff --git a/source/slang/decl-defs.h b/source/slang/decl-defs.h
index bb8c26f58..9c010d156 100644
--- a/source/slang/decl-defs.h
+++ b/source/slang/decl-defs.h
@@ -123,7 +123,7 @@ SYNTAX_CLASS(TypeDefDecl, SimpleTypeDecl)
 END_SYNTAX_CLASS()
 
 // An 'assoctype' declaration, it is a container of inheritance clauses
-SYNTAX_CLASS(AssocTypeDecl, ContainerDecl)
+SYNTAX_CLASS(AssocTypeDecl, AggTypeDecl)
 END_SYNTAX_CLASS()
 
 // A scope for local declarations (e.g., as part of a statement)
diff --git a/source/slang/emit.cpp b/source/slang/emit.cpp
index 9caad2e1a..2627e1f37 100644
--- a/source/slang/emit.cpp
+++ b/source/slang/emit.cpp
@@ -1052,15 +1052,6 @@ struct EmitVisitor
         EmitDeclarator(arg.declarator);
     }
 
-    void visitAssocTypeDeclRefType(AssocTypeDeclRefType* /*type*/, TypeEmitArg const& /*arg*/)
-    {
-        //SLANG_UNREACHABLE("visitAssocTypeDeclRefType in EmitVisitor");
-    }
-    void visitGenericConstraintDeclRefType(GenericConstraintDeclRefType* /*type*/, TypeEmitArg const& /*arg*/)
-    {
-        //SLANG_UNREACHABLE("visitGenericConstraintDeclRefType in EmitVisitor");
-    }
-
     void visitBasicExpressionType(BasicExpressionType* basicType, TypeEmitArg const& arg)
     {
         auto declarator = arg.declarator;
@@ -2925,7 +2916,7 @@ struct EmitVisitor
                 return;
             }
 
-            Substitutions* subst = declRef.substitutions.Ptr();
+            GenericSubstitution* subst = declRef.substitutions.As<GenericSubstitution>().Ptr();
             if (!subst)
                 return;
 
diff --git a/source/slang/ir.cpp b/source/slang/ir.cpp
index 84ab3d9a5..5f3ca6c62 100644
--- a/source/slang/ir.cpp
+++ b/source/slang/ir.cpp
@@ -178,27 +178,27 @@ namespace Slang
     //
 
     // Add an instruction to a specific parent
-    void IRBuilder::addInst(IRBlock* block, IRInst* inst)
+    void IRBuilder::addInst(IRBlock* pblock, IRInst* inst)
     {
-        inst->parent = block;
+        inst->parent = pblock;
 
-        if (!block->firstInst)
+        if (!pblock->firstInst)
         {
             inst->prev = nullptr;
             inst->next = nullptr;
 
-            block->firstInst = inst;
-            block->lastInst = inst;
+            pblock->firstInst = inst;
+            pblock->lastInst = inst;
         }
         else
         {
-            auto prev = block->lastInst;
+            auto prev = pblock->lastInst;
 
             inst->prev = prev;
             inst->next = nullptr;
 
             prev->next = inst;
-            block->lastInst = inst;
+            pblock->lastInst = inst;
         }
     }
 
@@ -206,7 +206,6 @@ namespace Slang
     void IRBuilder::addInst(
         IRInst*     inst)
     {
-        auto insertBefore = insertBeforeInst;
         if(insertBeforeInst)
         {
             inst->insertBefore(insertBeforeInst);
@@ -221,7 +220,7 @@ namespace Slang
     }
 
     static IRValue* createValueImpl(
-        IRBuilder*  builder,
+        IRBuilder*  /*builder*/,
         UInt        size,
         IROp        op,
         IRType*     type)
@@ -249,7 +248,7 @@ namespace Slang
     // arguments *after* the type (which is a mandatory
     // argument for all instructions).
     static IRInst* createInstImpl(
-        IRBuilder*      builder,
+        IRBuilder*      /*builder*/,
         UInt            size,
         IROp            op,
         IRType*         type,
@@ -261,8 +260,7 @@ namespace Slang
         IRInst* inst = (IRInst*) malloc(size);
         memset(inst, 0, size);
 
-        auto module = builder->getModule();
-        inst->argCount = fixedArgCount + varArgCount;
+        inst->argCount = (uint32_t)(fixedArgCount + varArgCount);
 
         inst->op = op;
 
@@ -632,7 +630,7 @@ namespace Slang
 
     IRInst* IRBuilder::emitCallInst(
         IRType*         type,
-        IRValue*        func,
+        IRValue*        pFunc,
         UInt            argCount,
         IRValue* const* args)
     {
@@ -641,7 +639,7 @@ namespace Slang
             kIROp_Call,
             type,
             1,
-            &func,
+            &pFunc,
             argCount,
             args);
         addInst(inst);
@@ -829,12 +827,12 @@ namespace Slang
 
     IRFunc* IRBuilder::createFunc()
     {
-        IRFunc* func = createValue<IRFunc>(
+        IRFunc* rsFunc = createValue<IRFunc>(
             this,
             kIROp_Func,
             nullptr);
-        addGlobalValue(getModule(), func);
-        return func;
+        addGlobalValue(getModule(), rsFunc);
+        return rsFunc;
     }
 
     IRGlobalVar* IRBuilder::createGlobalVar(
@@ -1129,13 +1127,13 @@ namespace Slang
     }
 
     IRInst* IRBuilder::emitBranch(
-        IRBlock*    block)
+        IRBlock*    pBlock)
     {
         auto inst = createInst<IRUnconditionalBranch>(
             this,
             kIROp_unconditionalBranch,
             nullptr,
-            block);
+            pBlock);
         addInst(inst);
         return inst;
     }
@@ -1543,7 +1541,7 @@ namespace Slang
 
         if(genericParentDeclRef)
         {
-            auto subst = declRef.substitutions;
+            auto subst = declRef.substitutions.As<GenericSubstitution>();
             if( !subst || subst->genericDecl != genericParentDeclRef.getDecl() )
             {
                 // No actual substitutions in place here
@@ -1698,6 +1696,7 @@ namespace Slang
         dumpChildrenRaw(context, block);
     }
 
+#if 0
     static void dumpChildrenRaw(
         IRDumpContext*  context,
         IRFunc*         func)
@@ -1720,6 +1719,7 @@ namespace Slang
         dumpIndent(context);
         dump(context, "}\n");
     }
+#endif
 
     static void dumpInst(
         IRDumpContext*  context,
@@ -2239,8 +2239,8 @@ namespace Slang
 
     void IRInst::removeArguments()
     {
-        UInt argCount = this->argCount;
-        for( UInt aa = 0; aa < argCount; ++aa )
+        UInt oldArgCount = this->argCount;
+        for( UInt aa = 0; aa < oldArgCount; ++aa )
         {
             IRUse& use = getArgs()[aa];
 
@@ -2384,9 +2384,9 @@ namespace Slang
         IRBuilder*                  builder,
         Type*                       type,
         VarLayout*                  varLayout,
-        TypeLayout*                 typeLayout,
-        LayoutResourceKind          kind,
-        GlobalVaryingDeclarator*    declarator)
+        TypeLayout*                 /*typeLayout*/,
+        LayoutResourceKind          /*kind*/,
+        GlobalVaryingDeclarator*    /*declarator*/)
     {
         // TODO: We might be creating an `in` or `out` variable based on
         // an `in out` function parameter. In this case we should
@@ -2550,7 +2550,6 @@ namespace Slang
 
         default:
             SLANG_UNEXPECTED("unimplemented");
-            return ScalarizedVal();
         }
 
     }
@@ -3079,7 +3078,6 @@ namespace Slang
             break;
         default:
             SLANG_UNEXPECTED("no value registered for IR value");
-            return nullptr;
         }
     }
 
@@ -3111,18 +3109,27 @@ namespace Slang
     {
         if (!subst)
             return nullptr;
+        if (auto genSubst = dynamic_cast<GenericSubstitution*>(subst))
+        {
+            RefPtr<GenericSubstitution> newSubst = new GenericSubstitution();
+            newSubst->outer = cloneSubstitutions(context, subst->outer);
+            newSubst->genericDecl = genSubst->genericDecl;
 
-        RefPtr<Substitutions> newSubst = new Substitutions();
-        newSubst->outer = cloneSubstitutions(context, subst->outer);
-        newSubst->genericDecl = subst->genericDecl;
-
-        for (auto arg : subst->args)
+            for (auto arg : genSubst->args)
+            {
+                auto newArg = cloneSubstitutionArg(context, arg);
+                newSubst->args.Add(arg);
+            }
+            return newSubst;
+        }
+        else if (auto thisSubst = dynamic_cast<ThisTypeSubstitution*>(subst))
         {
-            auto newArg = cloneSubstitutionArg(context, arg);
-            newSubst->args.Add(arg);
+            RefPtr<ThisTypeSubstitution> newSubst = new ThisTypeSubstitution();
+            newSubst->sourceType = thisSubst->sourceType;
+            newSubst->outer = cloneSubstitutions(context, subst->outer);
+            return newSubst;
         }
-
-        return newSubst;
+        return nullptr;
     }
 
     DeclRef<Decl> IRSpecContext::maybeCloneDeclRef(DeclRef<Decl> const& declRef)
@@ -3231,7 +3238,7 @@ namespace Slang
         {
             auto clonedKey = context->maybeCloneValue(originalEntry->requirementKey.usedValue);
             auto clonedVal = context->maybeCloneValue(originalEntry->satisfyingVal.usedValue);
-            auto clonedEntry = context->builder->createWitnessTableEntry(
+            context->builder->createWitnessTableEntry(
                 clonedTable,
                 clonedKey,
                 clonedVal);
@@ -3416,7 +3423,6 @@ namespace Slang
 
         default:
             SLANG_UNEXPECTED("unhandled case");
-            return "unknown";
         }
     }
 
@@ -3518,7 +3524,6 @@ namespace Slang
         {
             // This shouldn't happen!
             SLANG_UNEXPECTED("no matching function registered");
-            return cloneSimpleFunc(context, originalFunc);
         }
 
         // We will try to track the "best" definition we can find.
@@ -3748,7 +3753,6 @@ namespace Slang
         else
         {
             SLANG_UNEXPECTED("unimplemented");
-            return nullptr;
         }
     }
 
@@ -3756,7 +3760,8 @@ namespace Slang
         IRGenericSpecContext*   context,
         DeclRef<Decl>           declRef)
     {
-        auto subst = context->subst;
+        auto subst = context->subst.As<GenericSubstitution>();
+        SLANG_ASSERT(subst);
         auto genericDecl = subst->genericDecl;
 
         UInt orinaryParamCount = 0;
@@ -3806,12 +3811,13 @@ namespace Slang
             {
                 auto declRefVal = (IRDeclRef*) originalVal;
                 auto declRef = declRefVal->declRef;
-
+                auto genSubst = subst.As<GenericSubstitution>();
+                SLANG_ASSERT(genSubst);
                 // We may have a direct reference to one of the parameters
                 // of the generic we are specializing, and in that case
                 // we nee to translate it over to the equiavalent of
                 // the `Val` we have been given.
-                if(declRef.getDecl()->ParentDecl == subst->genericDecl)
+                if(declRef.getDecl()->ParentDecl == genSubst->genericDecl)
                 {
                     return getSubstValue(this, declRef);
                 }
@@ -3866,9 +3872,10 @@ namespace Slang
         // using a different overload of a target-specific function,
         // so we need to create a dummy substitution here, to make
         // sure it used the correct generic.
-        RefPtr<Substitutions> newSubst = new Substitutions();
+        RefPtr<GenericSubstitution> newSubst = new GenericSubstitution();
         newSubst->genericDecl = genericFunc->genericDecl;
-        newSubst->args = specDeclRef.substitutions->args;
+        auto specDeclRefSubst = specDeclRef.substitutions.As<GenericSubstitution>();
+        newSubst->args = specDeclRefSubst->args;
 
         IRGenericSpecContext context;
         context.shared = sharedContext;
diff --git a/source/slang/lookup.cpp b/source/slang/lookup.cpp
index b97dac560..a5425074f 100644
--- a/source/slang/lookup.cpp
+++ b/source/slang/lookup.cpp
@@ -452,28 +452,28 @@ void lookUpMemberImpl(
                 lookUpMemberImpl(session, semantics, name, bound, ioResult, &breadcrumb);
             }
         }
-    }
-    else if (auto assocTypeDeclRefType = type->As<AssocTypeDeclRefType>())
-    {
-        auto assocTypeDeclRef = assocTypeDeclRefType->declRef;
-        for (auto constraintDeclRef : getMembersOfType<GenericTypeConstraintDecl>(assocTypeDeclRef))
+        else if (auto assocTypeDeclRef = declRef.As<AssocTypeDecl>())
         {
-            // The super-type in the constraint (e.g., `Foo` in `T : Foo`)
-            // will tell us a type we should use for lookup.
-            auto bound = GetSup(constraintDeclRef);
+            for (auto constraintDeclRef : getMembersOfType<GenericTypeConstraintDecl>(assocTypeDeclRef))
+            {
+                // The super-type in the constraint (e.g., `Foo` in `T : Foo`)
+                // will tell us a type we should use for lookup.
+                auto bound = GetSup(constraintDeclRef);
 
-            // Go ahead and use the target type, with an appropriate breadcrumb
-            // to indicate that we indirected through a type constraint.
+                // Go ahead and use the target type, with an appropriate breadcrumb
+                // to indicate that we indirected through a type constraint.
 
-            BreadcrumbInfo breadcrumb;
-            breadcrumb.prev = inBreadcrumbs;
-            breadcrumb.kind = LookupResultItem::Breadcrumb::Kind::Constraint;
-            breadcrumb.declRef = constraintDeclRef;
+                BreadcrumbInfo breadcrumb;
+                breadcrumb.prev = inBreadcrumbs;
+                breadcrumb.kind = LookupResultItem::Breadcrumb::Kind::Constraint;
+                breadcrumb.declRef = constraintDeclRef;
 
-            // TODO: Need to consider case where this might recurse infinitely.
-            lookUpMemberImpl(session, semantics, name, bound, ioResult, &breadcrumb);
+                // TODO: Need to consider case where this might recurse infinitely.
+                lookUpMemberImpl(session, semantics, name, bound, ioResult, &breadcrumb);
+            }
         }
     }
+    
 }
 
 LookupResult lookUpMember(
diff --git a/source/slang/lower-to-ir.cpp b/source/slang/lower-to-ir.cpp
index 998197279..6099df1ed 100644
--- a/source/slang/lower-to-ir.cpp
+++ b/source/slang/lower-to-ir.cpp
@@ -870,9 +870,12 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
         auto subs = declRef.substitutions;
         while(subs)
         {
-            for(auto aa : subs->args)
+            if (auto genSubst = subs.As<GenericSubstitution>())
             {
-                (*ioArgs).Add(getSimpleVal(context, lowerVal(context, aa)));
+                for (auto aa : genSubst->args)
+                {
+                    (*ioArgs).Add(getSimpleVal(context, lowerVal(context, aa)));
+                }
             }
             subs = subs->outer;
         }
@@ -3037,24 +3040,33 @@ RefPtr<Substitutions> lowerSubstitutions(
 {
     if(!subst)
         return nullptr;
+    RefPtr<Substitutions> result;
+    if (auto genSubst = dynamic_cast<GenericSubstitution*>(subst))
+    {
+        RefPtr<GenericSubstitution> newSubst = new GenericSubstitution();
+        newSubst->genericDecl = genSubst->genericDecl;
+
+        for (auto arg : genSubst->args)
+        {
+            auto newArg = lowerSubstitutionArg(context, arg);
+            newSubst->args.Add(newArg);
+        }
 
-    RefPtr<Substitutions> newSubst = new Substitutions();
+        result = newSubst;
+    }
+    else if (auto thisSubst = dynamic_cast<ThisTypeSubstitution*>(subst))
+    {
+        RefPtr<ThisTypeSubstitution> newSubst = new ThisTypeSubstitution();
+        newSubst->sourceType = lowerSubstitutionArg(context, thisSubst->sourceType);
+        result = newSubst;
+    }
     if (subst->outer)
     {
-        newSubst->outer = lowerSubstitutions(
+        result->outer = lowerSubstitutions(
             context,
             subst->outer);
     }
-
-    newSubst->genericDecl = subst->genericDecl;
-
-    for (auto arg : subst->args)
-    {
-        auto newArg = lowerSubstitutionArg(context, arg);
-        newSubst->args.Add(newArg);
-    }
-
-    return newSubst;
+    return result;
 }
 
 LoweredValInfo emitDeclRef(
diff --git a/source/slang/lower.cpp b/source/slang/lower.cpp
index b810d9643..b8696df47 100644
--- a/source/slang/lower.cpp
+++ b/source/slang/lower.cpp
@@ -779,20 +779,6 @@ struct LoweringVisitor
             translateDeclRef(DeclRef<Decl>(type->declRef)).As<TypeDefDecl>());
     }
 
-    RefPtr<Type> visitGenericConstraintDeclRefType(GenericConstraintDeclRefType* type)
-    {
-        // not supported by lowering
-        SLANG_UNREACHABLE("visitGenericConstraintDeclRefType in LowerVisitor");
-        return nullptr;
-    }
-
-    RefPtr<Type> visitAssocTypeDeclRefType(AssocTypeDeclRefType* type)
-    {
-        // not supported by lowering
-        SLANG_UNREACHABLE("visitAssocTypeDeclRefType in LowerVisitor");
-        return nullptr;
-    }
-
     RefPtr<Type> visitTypeType(TypeType* type)
     {
         return getTypeType(lowerType(type->type));
@@ -2569,14 +2555,23 @@ struct LoweringVisitor
         Substitutions*  inSubstitutions)
     {
         if (!inSubstitutions) return nullptr;
-
-        RefPtr<Substitutions> result = new Substitutions();
-        result->genericDecl = translateDeclRef(inSubstitutions->genericDecl).As<GenericDecl>();
-        for (auto arg : inSubstitutions->args)
+        if (auto genSubst = dynamic_cast<GenericSubstitution*>(inSubstitutions))
         {
-            result->args.Add(translateVal(arg));
+            RefPtr<GenericSubstitution> result = new GenericSubstitution();
+            result->genericDecl = translateDeclRef(genSubst->genericDecl).As<GenericDecl>();
+            for (auto arg : genSubst->args)
+            {
+                result->args.Add(translateVal(arg));
+            }
+            return result;
         }
-        return result;
+        else if (auto thisSubst = dynamic_cast<ThisTypeSubstitution*>(inSubstitutions))
+        {
+            RefPtr<ThisTypeSubstitution> result = new ThisTypeSubstitution();
+            result->sourceType = translateVal(result->sourceType);
+            return result;
+        }
+        return nullptr;
     }
 
     static Decl* getModifiedDecl(Decl* decl)
@@ -2733,7 +2728,11 @@ struct LoweringVisitor
     RefPtr<VarLayout> tryToFindLayout(
         Decl* decl)
     {
-        auto loweredParent = translateDeclRef(decl->ParentDecl);
+        RefPtr<Decl> loweredParent;
+        if (auto genericParentDecl = decl->ParentDecl->As<GenericDecl>())
+            loweredParent = translateDeclRef(genericParentDecl->ParentDecl);
+        else
+            loweredParent = translateDeclRef(decl->ParentDecl);
         if (loweredParent)
         {
             auto layoutMod = loweredParent->FindModifier<ComputedLayoutModifier>();
@@ -3831,7 +3830,7 @@ struct LoweringVisitor
             "Vector").As<GenericDecl>();
         auto vectorTypeDecl = vectorGenericDecl->inner;
                
-        auto substitutions = new Substitutions();
+        auto substitutions = new GenericSubstitution();
         substitutions->genericDecl = vectorGenericDecl.Ptr();
         substitutions->args.Add(elementType);
         substitutions->args.Add(elementCount);
diff --git a/source/slang/mangle.cpp b/source/slang/mangle.cpp
index cd90a0e41..bde4e12c7 100644
--- a/source/slang/mangle.cpp
+++ b/source/slang/mangle.cpp
@@ -117,10 +117,6 @@ namespace Slang
         {
             emitQualifiedName(context, declRefType->declRef);
         }
-        else if (auto assocTypeDeclRefType = dynamic_cast<AssocTypeDeclRefType*>(type))
-        {
-            emitQualifiedName(context, assocTypeDeclRefType->declRef);
-        }
         else
         {
             SLANG_UNEXPECTED("unimplemented case in mangling");
@@ -199,7 +195,7 @@ namespace Slang
             // There are two cases here: either we have specializations
             // in place for the parent generic declaration, or we don't.
 
-            auto subst = declRef.substitutions;
+            auto subst = declRef.substitutions.As<GenericSubstitution>();
             if( subst && subst->genericDecl == parentGenericDeclRef.getDecl() )
             {
                 // This is the case where we *do* have substitutions.
diff --git a/source/slang/slang.natvis b/source/slang/slang.natvis
index 7a7f7fe0e..7e6fd3753 100644
--- a/source/slang/slang.natvis
+++ b/source/slang/slang.natvis
@@ -9,5 +9,30 @@
       <ExpandedItem>rawVal ? ($T1*)((char*)this + rawVal) : ($T1*)0</ExpandedItem>
     </Expand>
   </Type>
-  
+  <Type Name="Slang::DeclRef&lt;*&gt;">
+    <SmartPointer Usage="Minimal">decl ? ($T1*)(decl) : ($T1*)0</SmartPointer>
+    <DisplayString Condition="decl == 0">DeclRef nullptr</DisplayString>
+    <DisplayString Condition="decl != 0">DeclRef {(*(*(Slang::DeclRefBase*)this).decl).nameAndLoc}</DisplayString>
+    <Expand>
+      <ExpandedItem>decl ? ($T1*)(decl) : ($T1*)0</ExpandedItem>
+      <Item Name="[Substitutions]:">"========================="</Item>
+      <LinkedListItems>
+        <HeadPointer>substitutions.pointer</HeadPointer>
+        <NextPointer>outer.pointer</NextPointer>
+        <ValueNode>this</ValueNode>
+      </LinkedListItems>
+    </Expand>
+  </Type>
+  <Type Name="Slang::DeclRefType">
+    <DisplayString>DeclRefType {declRef}</DisplayString>
+    <Expand>
+      <ExpandedItem>declRef</ExpandedItem>
+    </Expand>
+  </Type>
+  <Type Name="Slang::Name">
+    <DisplayString>{{name={(char*)(text.buffer.pointer+1), s}}}</DisplayString>
+  </Type>
+  <Type Name="Slang::NameLoc">
+    <DisplayString>{{name={(char*)((*name).text.buffer.pointer+1), s} loc={loc.raw}}}</DisplayString>
+  </Type>
 </AutoVisualizer>
\ No newline at end of file
diff --git a/source/slang/syntax-base-defs.h b/source/slang/syntax-base-defs.h
index 8a22a61d2..3c7e8c5ae 100644
--- a/source/slang/syntax-base-defs.h
+++ b/source/slang/syntax-base-defs.h
@@ -126,31 +126,44 @@ protected:
     )
 END_SYNTAX_CLASS()
 
+
 // A substitution represents a binding of certain
 // type-level variables to concrete argument values
-SYNTAX_CLASS(Substitutions, RefObject)
+ABSTRACT_SYNTAX_CLASS(Substitutions, RefObject)
+
+    // Any further substitutions, relating to outer generic declarations
+    SYNTAX_FIELD(RefPtr<Substitutions>, outer)
+
+    RAW(
+    // Apply a set of substitutions to the bindings in this substitution
+    virtual RefPtr<Substitutions> SubstituteImpl(Substitutions* subst, int* ioDiff) = 0;
 
+    // Check if these are equivalent substitutiosn to another set
+    virtual bool Equals(Substitutions* subst) = 0;
+    virtual bool operator == (const Substitutions & subst) = 0;
+    virtual int GetHashCode() const = 0;
+    )
+END_SYNTAX_CLASS()
+
+SYNTAX_CLASS(GenericSubstitution, Substitutions)
     // The generic declaration that defines the
     // parametesr we are binding to arguments
-    DECL_FIELD(GenericDecl*,  genericDecl)
+    DECL_FIELD(GenericDecl*, genericDecl)
 
     // The actual values of the arguments
     SYNTAX_FIELD(List<RefPtr<Val>>, args)
-
-    // Any further substitutions, relating to outer generic declarations
-    SYNTAX_FIELD(RefPtr<Substitutions>, outer)
-
+    
     RAW(
     // Apply a set of substitutions to the bindings in this substitution
-    RefPtr<Substitutions> SubstituteImpl(Substitutions* subst, int* ioDiff);
+    virtual RefPtr<Substitutions> SubstituteImpl(Substitutions* subst, int* ioDiff) override;
 
     // Check if these are equivalent substitutiosn to another set
-    bool Equals(Substitutions* subst);
-    bool operator == (const Substitutions & subst)
+    virtual bool Equals(Substitutions* subst) override;
+    virtual bool operator == (const Substitutions & subst) override
     {
         return Equals(const_cast<Substitutions*>(&subst));
     }
-    int GetHashCode() const
+    virtual int GetHashCode() const override
     {
         int rs = 0;
         for (auto && v : args)
@@ -163,6 +176,27 @@ SYNTAX_CLASS(Substitutions, RefObject)
     )
 END_SYNTAX_CLASS()
 
+SYNTAX_CLASS(ThisTypeSubstitution, Substitutions)
+    // The actual type that provides the lookup scope for an associated type
+    SYNTAX_FIELD(RefPtr<Val>, sourceType)
+
+    RAW(
+    // Apply a set of substitutions to the bindings in this substitution
+    virtual RefPtr<Substitutions> SubstituteImpl(Substitutions* subst, int* ioDiff) override;
+
+    // Check if these are equivalent substitutiosn to another set
+    virtual bool Equals(Substitutions* subst) override;
+    virtual bool operator == (const Substitutions & subst) override
+    {
+        return Equals(const_cast<Substitutions*>(&subst));
+    }
+    virtual int GetHashCode() const override
+    {
+        return sourceType->GetHashCode();
+    }
+    )
+END_SYNTAX_CLASS()
+
 ABSTRACT_SYNTAX_CLASS(SyntaxNode, SyntaxNodeBase)
 END_SYNTAX_CLASS()
 
diff --git a/source/slang/syntax.cpp b/source/slang/syntax.cpp
index 3e38955ba..a3a5fdcb6 100644
--- a/source/slang/syntax.cpp
+++ b/source/slang/syntax.cpp
@@ -91,6 +91,8 @@ ABSTRACT_SYNTAX_CLASS(Modifier, SyntaxNodeBase);
 ABSTRACT_SYNTAX_CLASS(Expr, SyntaxNode);
 
 ABSTRACT_SYNTAX_CLASS(Substitutions, SyntaxNode);
+ABSTRACT_SYNTAX_CLASS(GenericSubstitution, Substitutions);
+ABSTRACT_SYNTAX_CLASS(ThisTypeSubstitution, Substitutions);
 
 #include "expr-defs.h"
 #include "decl-defs.h"
@@ -98,8 +100,6 @@ ABSTRACT_SYNTAX_CLASS(Substitutions, SyntaxNode);
 #include "stmt-defs.h"
 #include "type-defs.h"
 #include "val-defs.h"
-
-
 #include "object-meta-end.h"
 
 bool SyntaxClassBase::isSubClassOfImpl(SyntaxClassBase const& super) const
@@ -283,7 +283,7 @@ void Type::accept(IValVisitor* visitor, void* extra)
             this, "PtrType").As<GenericDecl>();
         auto typeDecl = genericDecl->inner;
                
-        auto substitutions = new Substitutions();
+        auto substitutions = new GenericSubstitution();
         substitutions->genericDecl = genericDecl.Ptr();
         substitutions->args.Add(valueType);
 
@@ -414,38 +414,57 @@ void Type::accept(IValVisitor* visitor, void* extra)
             // search for a substitution that might apply to us
             for (auto s = subst; s; s = s->outer.Ptr())
             {
-                // the generic decl associated with the substitution list must be
-                // the generic decl that declared this parameter
-                auto genericDecl = s->genericDecl;
-                if (genericDecl != genericTypeParamDecl->ParentDecl)
-                    continue;
-
-                int index = 0;
-                for (auto m : genericDecl->Members)
+                if (auto genericSubst = dynamic_cast<GenericSubstitution*>(s))
                 {
-                    if (m.Ptr() == genericTypeParamDecl)
-                    {
-                        // We've found it, so return the corresponding specialization argument
-                        (*ioDiff)++;
-                        return s->args[index];
-                    }
-                    else if(auto typeParam = m.As<GenericTypeParamDecl>())
+                    // the generic decl associated with the substitution list must be
+                    // the generic decl that declared this parameter
+                    auto genericDecl = genericSubst->genericDecl;
+                    if (genericDecl != genericTypeParamDecl->ParentDecl)
+                        continue;
+
+                    int index = 0;
+                    for (auto m : genericDecl->Members)
                     {
-                        index++;
-                    }
-                    else if(auto valParam = m.As<GenericValueParamDecl>())
-                    {
-                        index++;
+                        if (m.Ptr() == genericTypeParamDecl)
+                        {
+                            // We've found it, so return the corresponding specialization argument
+                            (*ioDiff)++;
+                            return genericSubst->args[index];
+                        }
+                        else if (auto typeParam = m.As<GenericTypeParamDecl>())
+                        {
+                            index++;
+                        }
+                        else if (auto valParam = m.As<GenericValueParamDecl>())
+                        {
+                            index++;
+                        }
+                        else
+                        {
+                        }
                     }
-                    else
+                }
+               
+            }
+        }
+        // the second case we care about is when this decl type refers to an associatedtype decl
+        // we want to replace it with the actual associated type
+        else if (auto assocTypeDecl = dynamic_cast<AssocTypeDecl*>(declRef.getDecl()))
+        {
+            // search for a substitution that might apply to us
+            for (auto s = subst; s; s = s->outer.Ptr())
+            {
+                if (auto thisTypeSubst = dynamic_cast<ThisTypeSubstitution*>(s))
+                {
+                    if (auto aggTypeDeclRef = thisTypeSubst->sourceType.As<DeclRefType>()->declRef.As<AggTypeDecl>())
                     {
+                        Decl * targetType = nullptr;
+                        if (aggTypeDeclRef.getDecl()->memberDictionary.TryGetValue(assocTypeDecl->getName(), targetType))
+                            return DeclRefType::Create(this->getSession(), DeclRef<Decl>(targetType, aggTypeDeclRef.substitutions));
                     }
                 }
-
             }
         }
-
-
         int diff = 0;
         DeclRef<Decl> substDeclRef = declRef.SubstituteImpl(subst, &diff);
 
@@ -486,10 +505,25 @@ void Type::accept(IValVisitor* visitor, void* extra)
         // we will construct a default specialization at the use
         // site if needed.
 
-        if( auto genericParent = declRef.GetParent().As<GenericDecl>() )
+        if (auto genericParent = declRef.GetParent().As<GenericDecl>())
         {
             auto subst = declRef.substitutions;
-            if( !subst || subst->genericDecl != genericParent.decl )
+            // try find a substitution targeting this generic decl
+            bool substFound = false;
+            while (subst)
+            {
+                if (auto genSubst = dynamic_cast<GenericSubstitution*>(subst.Ptr()))
+                {
+                    if (genSubst->genericDecl == genericParent.decl)
+                    {
+                        substFound = true;
+                        break;
+                    }
+                }
+                subst = subst->outer;
+            }
+            // we did not find an existing substituion, create a default one
+            if (!substFound)
             {
                 declRef.substitutions = createDefaultSubstitutions(
                     session,
@@ -507,7 +541,7 @@ void Type::accept(IValVisitor* visitor, void* extra)
         }
         else if (auto magicMod = declRef.getDecl()->FindModifier<MagicTypeModifier>())
         {
-            Substitutions* subst = declRef.substitutions.Ptr();
+            GenericSubstitution* subst = declRef.substitutions.As<GenericSubstitution>().Ptr();
 
             if (magicMod->name == "SamplerState")
             {
@@ -761,7 +795,6 @@ void Type::accept(IValVisitor* visitor, void* extra)
     bool NamedExpressionType::EqualsImpl(Type * /*type*/)
     {
         SLANG_UNEXPECTED("unreachable");
-        return false;
     }
 
     Type* NamedExpressionType::CreateCanonicalType()
@@ -772,7 +805,6 @@ void Type::accept(IValVisitor* visitor, void* extra)
     int NamedExpressionType::GetHashCode()
     {
         SLANG_UNEXPECTED("unreachable");
-        return 0;
     }
 
     // FuncType
@@ -910,7 +942,6 @@ void Type::accept(IValVisitor* visitor, void* extra)
     int TypeType::GetHashCode()
     {
         SLANG_UNEXPECTED("unreachable");
-        return 0;
     }
 
     // GenericDeclRefType
@@ -940,125 +971,6 @@ void Type::accept(IValVisitor* visitor, void* extra)
         return this;
     }
 
-    // AssocTypeDeclRefType
-
-    String AssocTypeDeclRefType::ToString()
-    {
-        // TODO: what is appropriate here?
-        return "<AssocType>";
-    }
-
-    bool AssocTypeDeclRefType::EqualsImpl(Type * type)
-    {
-        if (auto assocTypeDeclRefType = type->As<AssocTypeDeclRefType>())
-        {
-            return declRef.Equals(assocTypeDeclRefType->declRef);
-        }
-        return false;
-    }
-
-    RefPtr<Val> AssocTypeDeclRefType::SubstituteImpl(Substitutions* subst, int* ioDiff)
-    {
-        if (!sourceType)
-            return this;
-        auto substSourceType = sourceType->SubstituteImpl(subst, ioDiff);
-        if (auto parentDeclRefType = substSourceType.As<DeclRefType>())
-        {
-            auto parentDeclRef = parentDeclRefType->declRef;
-            DeclRef<AggTypeDecl> newParentDeclRef = parentDeclRef.As<AggTypeDecl>();
-            // search for a substitution that might apply to us
-            for (auto s = subst; s; s = s->outer.Ptr())
-            {
-                // the generic decl associated with the substitution list must be
-                // the generic decl that declared this parameter
-                auto genericDecl = s->genericDecl;
-                if (genericDecl != parentDeclRef.getDecl()->ParentDecl)
-                    continue;
-                int index = 0;
-                for (auto m : genericDecl->Members)
-                {
-                    if (m.Ptr() == parentDeclRef.getDecl())
-                    {
-                        // We've found it, so return the corresponding specialization argument
-                        (*ioDiff)++;
-                        if (auto declRef = s->args[index].As<DeclRefType>())
-                        {
-                            newParentDeclRef = (*declRef).declRef.As<AggTypeDecl>();
-                            goto searchEnd;
-                        }
-                    }
-                    else if (auto typeParam = m.As<GenericTypeParamDecl>())
-                    {
-                        index++;
-                    }
-                    else if (auto valParam = m.As<GenericValueParamDecl>())
-                    {
-                        index++;
-                    }
-                    else
-                    {
-                    }
-                }
-            }
-        searchEnd:
-            if (newParentDeclRef)
-            {
-                Decl* targetTypeDecl = nullptr;
-                if (newParentDeclRef.getDecl()->memberDictionary.TryGetValue(this->GetDeclRef().decl->getName(), targetTypeDecl))
-                {
-                    if (auto typeDefDecl = targetTypeDecl->As<TypeDefDecl>())
-                        return GetType(DeclRef<TypeDefDecl>(typeDefDecl, subst));
-                    else
-                        return DeclRefType::Create(this->getSession(), DeclRef<Decl>(targetTypeDecl, subst));
-                }
-            }
-        }
-       
-        return this;
-    }
-
-    int AssocTypeDeclRefType::GetHashCode()
-    {
-        return declRef.GetHashCode();
-    }
-
-    Type* AssocTypeDeclRefType::CreateCanonicalType()
-    {
-        return this;
-    }
-
-    // GenericConstraintDeclRefType
-
-    String GenericConstraintDeclRefType::ToString()
-    {
-        // TODO: what is appropriate here?
-        return "<GenericConstraintType>";
-    }
-
-    bool GenericConstraintDeclRefType::EqualsImpl(Type * type)
-    {
-        if (auto other = type->As<GenericConstraintDeclRefType>())
-        {
-            return supType->Equals(other->supType) && subType->Equals(other->subType);
-        }
-        return false;
-    }
-
-    RefPtr<Val> GenericConstraintDeclRefType::SubstituteImpl(Substitutions* subst, int* ioDiff)
-    {
-        return subType->SubstituteImpl(subst, ioDiff);
-    }
-
-    int GenericConstraintDeclRefType::GetHashCode()
-    {
-        return combineHash(subType.GetHashCode(), supType.GetHashCode());
-    }
-
-    Type* GenericConstraintDeclRefType::CreateCanonicalType()
-    {
-        return this;
-    }
-
     // ArithmeticExpressionType
 
     // VectorExpressionType
@@ -1091,24 +1003,24 @@ void Type::accept(IValVisitor* visitor, void* extra)
 
     Type* MatrixExpressionType::getElementType()
     {
-        return this->declRef.substitutions->args[0].As<Type>().Ptr();
+        return this->declRef.substitutions.As<GenericSubstitution>()->args[0].As<Type>().Ptr();
     }
 
     IntVal* MatrixExpressionType::getRowCount()
     {
-        return this->declRef.substitutions->args[1].As<IntVal>().Ptr();
+        return this->declRef.substitutions.As<GenericSubstitution>()->args[1].As<IntVal>().Ptr();
     }
 
     IntVal* MatrixExpressionType::getColumnCount()
     {
-        return this->declRef.substitutions->args[2].As<IntVal>().Ptr();
+        return this->declRef.substitutions.As<GenericSubstitution>()->args[2].As<IntVal>().Ptr();
     }
 
     // PtrTypeBase
 
     Type* PtrTypeBase::getValueType()
     {
-        return this->declRef.substitutions->args[0].As<Type>().Ptr();
+        return this->declRef.substitutions.As<GenericSubstitution>()->args[0].As<Type>().Ptr();
     }
 
     // GenericParamIntVal
@@ -1137,31 +1049,34 @@ void Type::accept(IValVisitor* visitor, void* extra)
         // search for a substitution that might apply to us
         for (auto s = subst; s; s = s->outer.Ptr())
         {
-            // the generic decl associated with the substitution list must be
-            // the generic decl that declared this parameter
-            auto genericDecl = s->genericDecl;
-            if (genericDecl != declRef.getDecl()->ParentDecl)
-                continue;
-
-            int index = 0;
-            for (auto m : genericDecl->Members)
+            if (auto genSubst = dynamic_cast<GenericSubstitution*>(s))
             {
-                if (m.Ptr() == declRef.getDecl())
-                {
-                    // We've found it, so return the corresponding specialization argument
-                    (*ioDiff)++;
-                    return s->args[index];
-                }
-                else if(auto typeParam = m.As<GenericTypeParamDecl>())
-                {
-                    index++;
-                }
-                else if(auto valParam = m.As<GenericValueParamDecl>())
-                {
-                    index++;
-                }
-                else
+                // the generic decl associated with the substitution list must be
+                // the generic decl that declared this parameter
+                auto genericDecl = genSubst->genericDecl;
+                if (genericDecl != declRef.getDecl()->ParentDecl)
+                    continue;
+
+                int index = 0;
+                for (auto m : genericDecl->Members)
                 {
+                    if (m.Ptr() == declRef.getDecl())
+                    {
+                        // We've found it, so return the corresponding specialization argument
+                        (*ioDiff)++;
+                        return genSubst->args[index];
+                    }
+                    else if (auto typeParam = m.As<GenericTypeParamDecl>())
+                    {
+                        index++;
+                    }
+                    else if (auto valParam = m.As<GenericValueParamDecl>())
+                    {
+                        index++;
+                    }
+                    else
+                    {
+                    }
                 }
             }
         }
@@ -1172,12 +1087,12 @@ void Type::accept(IValVisitor* visitor, void* extra)
 
     // Substitutions
 
-    RefPtr<Substitutions> Substitutions::SubstituteImpl(Substitutions* subst, int* ioDiff)
+    RefPtr<Substitutions> GenericSubstitution::SubstituteImpl(Substitutions* subst, int* ioDiff)
     {
         if (!this) return nullptr;
 
         int diff = 0;
-        auto outerSubst = outer->SubstituteImpl(subst, &diff);
+        auto outerSubst = outer ? outer->SubstituteImpl(subst, &diff) : nullptr;
 
         List<RefPtr<Val>> substArgs;
         for (auto a : args)
@@ -1188,35 +1103,73 @@ void Type::accept(IValVisitor* visitor, void* extra)
         if (!diff) return this;
 
         (*ioDiff)++;
-        auto substSubst = new Substitutions();
+        auto substSubst = new GenericSubstitution();
         substSubst->genericDecl = genericDecl;
         substSubst->args = substArgs;
         return substSubst;
     }
 
-    bool Substitutions::Equals(Substitutions* subst)
+    bool GenericSubstitution::Equals(Substitutions* subst)
     {
         // both must be NULL, or non-NULL
         if (!this || !subst)
             return !this && !subst;
-
-        if (genericDecl != subst->genericDecl)
+        auto genericSubst = dynamic_cast<GenericSubstitution*>(subst);
+        if (!genericSubst)
+            return false;
+        if (genericDecl != genericSubst->genericDecl)
             return false;
 
         UInt argCount = args.Count();
-        SLANG_RELEASE_ASSERT(args.Count() == subst->args.Count());
+        SLANG_RELEASE_ASSERT(args.Count() == genericSubst->args.Count());
         for (UInt aa = 0; aa < argCount; ++aa)
         {
-            if (!args[aa]->EqualsVal(subst->args[aa].Ptr()))
+            if (!args[aa]->EqualsVal(genericSubst->args[aa].Ptr()))
                 return false;
         }
 
+        if (!outer)
+            return !subst->outer;
+
         if (!outer->Equals(subst->outer.Ptr()))
             return false;
 
         return true;
     }
 
+    RefPtr<Substitutions> ThisTypeSubstitution::SubstituteImpl(Substitutions* subst, int* ioDiff)
+    {
+        if (!this) return nullptr;
+
+        int diff = 0;
+        auto outerSubst = outer->SubstituteImpl(subst, &diff);
+        
+        auto newSourceType = sourceType->SubstituteImpl(subst, ioDiff);
+        if (!diff) return this;
+
+        (*ioDiff)++;
+        auto substSubst = new ThisTypeSubstitution();
+        substSubst->sourceType = newSourceType;
+        substSubst->outer = outerSubst;
+        return substSubst;
+    }
+
+    bool ThisTypeSubstitution::Equals(Substitutions* subst)
+    {
+        // both must be NULL, or non-NULL
+        if (!this || !subst)
+            return !this && !subst;
+        auto thisSubst = dynamic_cast<ThisTypeSubstitution*>(subst);
+        if (!thisSubst)
+            return false;
+        if (!thisSubst->sourceType->EqualsVal(sourceType))
+            return false;
+        if (!outer->Equals(subst->outer.Ptr()))
+            return false;
+        return true;
+    }
+
+
 
     // DeclRefBase
 
@@ -1248,8 +1201,6 @@ void Type::accept(IValVisitor* visitor, void* extra)
             return expr;
 
         SLANG_UNIMPLEMENTED_X("generic substitution into expressions");
-
-        return expr;
     }
 
 
@@ -1277,7 +1228,8 @@ void Type::accept(IValVisitor* visitor, void* extra)
     {
         if (decl != declRef.decl)
             return false;
-
+        if (!substitutions)
+            return !declRef.substitutions;
         if (!substitutions->Equals(declRef.substitutions.Ptr()))
             return false;
 
@@ -1298,7 +1250,8 @@ void Type::accept(IValVisitor* visitor, void* extra)
 
         if (auto parentGeneric = dynamic_cast<GenericDecl*>(parentDecl))
         {
-            if (substitutions && substitutions->genericDecl == parentDecl)
+            auto genSubst = substitutions.As<GenericSubstitution>();
+            if (genSubst && genSubst->genericDecl == parentDecl)
             {
                 // We strip away the specializations that were applied to
                 // the parent, since we were asked for a reference *to* the parent.
@@ -1427,7 +1380,6 @@ void Type::accept(IValVisitor* visitor, void* extra)
         else
         {
             SLANG_UNEXPECTED("unhandled syntax class name");
-            return nullptr;
         }
     }
 
@@ -1437,12 +1389,12 @@ void Type::accept(IValVisitor* visitor, void* extra)
 
     Type* HLSLPatchType::getElementType()
     {
-        return this->declRef.substitutions->args[0].As<Type>().Ptr();
+        return this->declRef.substitutions.As<GenericSubstitution>()->args[0].As<Type>().Ptr();
     }
 
     IntVal* HLSLPatchType::getElementCount()
     {
-        return this->declRef.substitutions->args[1].As<IntVal>().Ptr();
+        return this->declRef.substitutions.As<GenericSubstitution>()->args[1].As<IntVal>().Ptr();
     }
 
     // Constructors for types
diff --git a/source/slang/type-defs.h b/source/slang/type-defs.h
index 2052e1eb8..60f519c82 100644
--- a/source/slang/type-defs.h
+++ b/source/slang/type-defs.h
@@ -489,59 +489,4 @@ protected:
     virtual int GetHashCode() override;
     virtual Type* CreateCanonicalType() override;
 )
-END_SYNTAX_CLASS()
-
-// The "type" of an expression that references a asscoiated type decl (via 'assoctype' keyword).
-SYNTAX_CLASS(AssocTypeDeclRefType, Type)
-    DECL_FIELD(DeclRef<AssocTypeDecl>, declRef)
-    DECL_FIELD(RefPtr<Type>, sourceType)
-    RAW(
-    AssocTypeDeclRefType()
-    {}
-    AssocTypeDeclRefType(
-        DeclRef<AssocTypeDecl> declRef)
-        : declRef(declRef)
-    {}
-
-
-    DeclRef<AssocTypeDecl> const& GetDeclRef() const { return declRef; }
-
-    virtual String ToString() override;
-
-    protected:
-        virtual RefPtr<Val> SubstituteImpl(Substitutions* subst, int* ioDiff) override;
-        virtual bool EqualsImpl(Type * type) override;
-        virtual int GetHashCode() override;
-        virtual Type* CreateCanonicalType() override;
-    )
-END_SYNTAX_CLASS()
-
-// The "type" of an generic constraint, which wraps both the sub and sup (interface) type
-// the sub type can be used in associated type substitution in later type evaluation
-SYNTAX_CLASS(GenericConstraintDeclRefType, Type)
-    DECL_FIELD(RefPtr<Type>, subType)
-    DECL_FIELD(RefPtr<Type>, supType)
-RAW(
-    GenericConstraintDeclRefType()
-    {}
-    GenericConstraintDeclRefType(Session* session, 
-        RefPtr<Type> sub,
-        RefPtr<Type> sup)
-        : subType(sub), supType(sup)
-    {
-        setSession(session);
-    }
-
-
-    RefPtr<Type> const& GetSupType() const { return supType; }
-    RefPtr<Type> const& GetSubType() const { return subType; }
-
-    virtual String ToString() override;
-
-    protected:
-        virtual RefPtr<Val> SubstituteImpl(Substitutions* subst, int* ioDiff) override;
-        virtual bool EqualsImpl(Type * type) override;
-        virtual int GetHashCode() override;
-        virtual Type* CreateCanonicalType() override;
-)
 END_SYNTAX_CLASS()
\ No newline at end of file
diff --git a/source/slang/vm.cpp b/source/slang/vm.cpp
index f129d15e0..d5bacaa36 100644
--- a/source/slang/vm.cpp
+++ b/source/slang/vm.cpp
@@ -513,8 +513,8 @@ void computeTypeSizeAlign(
         break;
 
     default:
-        SLANG_UNIMPLEMENTED_X("type sizing");
         impl->size = 0;
+        SLANG_UNIMPLEMENTED_X("type sizing");
         break;
     }
 
@@ -528,7 +528,7 @@ void computeTypeSizeAlign(
 }
 
 VMType getType(
-    VM*         vm,
+    VM*         /*vm*/,
     VMTypeImpl* typeImpl)
 {
     // TODO: need to look up an existing type that matches...
@@ -587,7 +587,7 @@ VMType loadVMType(
             VMTypeImpl* impl = (VMTypeImpl*) alloca(size);
             memset(impl, 0, size);
             impl->op = bcType->op;
-            impl->argCount = argCount;
+            impl->argCount = (uint32_t)argCount;
             
             VMVal* args = (VMVal*) (impl + 1);
             for(UInt aa = 0; aa < argCount; ++aa)
@@ -597,14 +597,11 @@ VMType loadVMType(
 
             return getType(vmModule->vm, impl);
         }
-
-        SLANG_UNEXPECTED("unimplemented");
-        return VMType();
         break;
     }
 }
 
-void* allocateImpl(VM* vm, UInt size, UInt align)
+void* allocateImpl(VM* /*vm*/, UInt size, UInt /*align*/)
 {
     void* ptr = malloc(size);
     memset(ptr, 0, size);
@@ -666,7 +663,7 @@ void* loadVMSymbol(
 VMModule* loadVMModuleInstance(
     VM*         vm,
     void const* bytecode,
-    size_t      bytecodeSize)
+    size_t      /*bytecodeSize*/)
 {
     BCHeader* bcHeader = (BCHeader*) bytecode;
 
@@ -732,14 +729,14 @@ void* findGlobalSymbolPtr(
             continue;
 
         if(strcmp(symbolName, name) == 0)
-            return getGlobalPtr(module, ss);
+            return getGlobalPtr(module, (uint32_t)ss);
     }
 
     return nullptr;
 }
 
 VMThread* createThread(
-    VM* vm)
+    VM* /*vm*/)
 {
     VMThread* thread = new VMThread();
     thread->frame = nullptr;
@@ -863,7 +860,7 @@ void resumeThread(
         case kIROp_BufferStore:
             {
                 VMType resultType = decodeType(frame, &ip);
-                UInt argCount = decodeUInt(&ip);
+                /*UInt argCount =*/ decodeUInt(&ip);
 
                 char* bufferData = decodeOperand<char*>(frame, &ip);
                 uint32_t index = decodeOperand<uint32_t>(frame, &ip);
@@ -944,10 +941,9 @@ void resumeThread(
         case kIROp_ReturnVal:
             {
                 VMType instType = decodeType(frame, &ip);
-                UInt argCount = decodeUInt(&ip);
+                /*UInt argCount =*/ decodeUInt(&ip);
                 void* argPtr = decodeOperandPtr<void>(frame, &ip);
 
-                VMFrame* oldFrame = frame;
                 VMFrame* newFrame = frame->parent;
                 vmThread->frame = newFrame;
 
@@ -980,7 +976,7 @@ void resumeThread(
                 Int destinationBlock = decodeSInt(&ip);
                 for( UInt aa = 2; aa < argCount; ++aa )
                 {
-                    void* argPtr = decodeOperandPtr<void>(frame, &ip);
+                    decodeOperandPtr<void>(frame, &ip);
                 }
 
                 // TODO: we need to deal with the case of
@@ -1006,7 +1002,7 @@ void resumeThread(
                 Int falseBlockID = decodeSInt(&ip);
                 for( UInt aa = 4; aa < argCount; ++aa )
                 {
-                    void* argPtr = decodeOperandPtr<void>(frame, &ip);
+                    decodeOperandPtr<void>(frame, &ip);
                 }
 
                 Int destinationBlock = *condition ? trueBlockID : falseBlockID;
@@ -1025,7 +1021,7 @@ void resumeThread(
                 // knowing too much about an instruction...
 
                 VMType resultType = decodeType(frame, &ip);
-                UInt argCount = decodeUInt(&ip);
+                /*UInt argCount =*/ decodeUInt(&ip);
                 void* argPtrs[16] = { 0 };
                 auto leftOpnd = decodeOperandPtrAndType(frame, &ip);
                 auto type = leftOpnd.type;
@@ -1050,7 +1046,7 @@ void resumeThread(
         case kIROp_Mul:
             {
                 VMType type = decodeType(frame, &ip);
-                UInt argCount = decodeUInt(&ip);
+                /*UInt argCount =*/ decodeUInt(&ip);
                 void* leftPtr = decodeOperandPtr<void>(frame, &ip);
                 void* rightPtr = decodeOperandPtr<void>(frame, &ip);
 
@@ -1072,7 +1068,7 @@ void resumeThread(
         case kIROp_Sub:
             {
                 VMType type = decodeType(frame, &ip);
-                UInt argCount = decodeUInt(&ip);
+                /*UInt argCount =*/ decodeUInt(&ip);
                 void* leftPtr = decodeOperandPtr<void>(frame, &ip);
                 void* rightPtr = decodeOperandPtr<void>(frame, &ip);
 
diff --git a/tests/compute/assoctype-complex.slang b/tests/compute/assoctype-complex.slang
index de3f1a103..f29d231b6 100644
--- a/tests/compute/assoctype-complex.slang
+++ b/tests/compute/assoctype-complex.slang
@@ -30,30 +30,18 @@ struct Simple : ISimple
         return v0.sub(4, v1.sub(1,2));
     }
 };
-/*
+
 __generic<T:ISimple>
 T.U.V test(T simple, T.U v0, T.U v1)
 {
     return simple.add(v0, v1);
 }
 
-__generic<T:__BuiltinArithmeticType>
-T test(T v0, T v1)
-{
-    return v0 + v1;
-}
-*/
-__generic<T:__BuiltinFloatingPointType>
-T test(T v0, T v1)
-{
-    return T(3.0);
-}
 [numthreads(4, 1, 1)]
 void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
 {
-    //Simple s;
-    //Val v0, v1;
-	//float outVal = test(s, v0, v1); // == 1.0
-    float outVal = test<float>(1.0, 2.0);
+    Simple s;
+    Val v0, v1;
+	float outVal = test(s, v0, v1); // == 1.0
 	outputBuffer[dispatchThreadID.x] = outVal;
 }
\ No newline at end of file
diff --git a/tests/compute/generics-constraint1.slang b/tests/compute/generics-constraint1.slang
index ff90c1cc9..aa8d398e8 100644
--- a/tests/compute/generics-constraint1.slang
+++ b/tests/compute/generics-constraint1.slang
@@ -6,7 +6,7 @@ RWStructuredBuffer<float> outputBuffer;
 __generic<T:__BuiltinFloatingPointType>
 T test(T v0, T v1)
 {
-    return T(3.0);
+    return v0;
 }
 
 [numthreads(4, 1, 1)]
diff --git a/tests/compute/generics-constructor.slang b/tests/compute/generics-constructor.slang
new file mode 100644
index 000000000..c7473cc8b
--- /dev/null
+++ b/tests/compute/generics-constructor.slang
@@ -0,0 +1,17 @@
+//TEST(smoke, compute):COMPARE_COMPUTE:-xslang -use-ir
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):dxbinding(0),glbinding(0),out
+
+RWStructuredBuffer<float> outputBuffer;
+
+__generic<T:__BuiltinFloatingPointType>
+T test(T v0, T v1)
+{
+    return T(3.0);
+}
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{ 
+    float outVal = test<float>(1.0, 2.0);
+	outputBuffer[dispatchThreadID.x] = outVal;
+}
\ No newline at end of file