Redesign `DeclRef` and systematic `Val` deduplication (#3049)

* Redesign DeclRef + Deduplicate Val.

* Update project files

* Fix warning.

* Fix.

* Fix.

* Remove `Val::_equalsImplOverride`.

* Rmove `Val::_getHashCodeOverride`.

* Remove `semanticVisitor` param from `resolve`.

* Cleanups.

---------

Co-authored-by: Yong He <yhe@nvidia.com>

82 files changed, 4374 insertions, 6321 deletions

diff --git a/source/compiler-core/slang-diagnostic-sink.h b/source/compiler-core/slang-diagnostic-sink.h
index e4d131e37..fc5e31b47 100644
--- a/source/compiler-core/slang-diagnostic-sink.h
+++ b/source/compiler-core/slang-diagnostic-sink.h
@@ -310,7 +310,7 @@ private:
 class DiagnosticsLookup : public RefObject
 {
 public:
-    static const Index kArenaInitialSize = 2048;
+    static const Index kArenaInitialSize = 65536;
 
         /// Will take into account the slice name could be using different conventions
     const DiagnosticInfo* findDiagnosticByName(const UnownedStringSlice& slice) const;
diff --git a/source/compiler-core/slang-name.cpp b/source/compiler-core/slang-name.cpp
index cc2033339..c815b8aa8 100644
--- a/source/compiler-core/slang-name.cpp
+++ b/source/compiler-core/slang-name.cpp
@@ -19,7 +19,7 @@ const char* getCstr(Name* name)
     return name ? name->text.getBuffer() : nullptr;
 }
 
-Name* NamePool::getName(String const& text)
+Name* NamePool::getName(UnownedStringSlice text)
 {
     RefPtr<Name> name;
     if (rootPool->names.tryGetValue(text, name))
@@ -31,6 +31,11 @@ Name* NamePool::getName(String const& text)
     return name;
 }
 
+Name* NamePool::getName(String const& text)
+{
+    return getName(text.getUnownedSlice());
+}
+
 Name* NamePool::tryGetName(String const& text)
 {
     RefPtr<Name> name;
diff --git a/source/compiler-core/slang-name.h b/source/compiler-core/slang-name.h
index cf702686b..f8c1201af 100644
--- a/source/compiler-core/slang-name.h
+++ b/source/compiler-core/slang-name.h
@@ -68,6 +68,7 @@ struct RootNamePool
 struct NamePool
 {
     // Find or create the `Name` that represents the given `text`.
+    Name* getName(UnownedStringSlice text);
     Name* getName(String const& text);
     // Try find the `Name` that represents the given `text`.
     // If the name does not exist, return nullptr
diff --git a/source/compiler-core/slang-slice-allocator.h b/source/compiler-core/slang-slice-allocator.h
index e4ba9e907..a6f0cd5c1 100644
--- a/source/compiler-core/slang-slice-allocator.h
+++ b/source/compiler-core/slang-slice-allocator.h
@@ -97,7 +97,7 @@ struct SliceAllocator
     void deallocateAll() { m_arena.deallocateAll(); }
 
     SliceAllocator():
-        m_arena(1024)
+        m_arena(2097152)
     {
     }
 protected:
diff --git a/source/core/slang-array-view.h b/source/core/slang-array-view.h
index 99609ef69..50270e0a0 100644
--- a/source/core/slang-array-view.h
+++ b/source/core/slang-array-view.h
@@ -197,6 +197,8 @@ namespace Slang
             return ThisType(m_buffer + index, m_count - index);
         }
 
+        T& getLast() { return m_buffer[m_count - 1]; }
+
         ArrayView() : Super() {}
         ArrayView(T* buffer, Index size) :Super(buffer, size) {}
     };
diff --git a/source/core/slang-hash.h b/source/core/slang-hash.h
index bc4b30ccc..5f6b1b060 100644
--- a/source/core/slang-hash.h
+++ b/source/core/slang-hash.h
@@ -138,7 +138,7 @@ namespace Slang
 		template<typename TKey>
 		static HashCode getHashCode(TKey const& key)
 		{
-			return (HashCode)((PtrInt)key) / 16; // sizeof(typename std::remove_pointer<TKey>::type);
+			return (HashCode)((PtrInt)key) >> 2; // sizeof(typename std::remove_pointer<TKey>::type);
 		}
 	};
 	template<>
diff --git a/source/core/slang-list.h b/source/core/slang-list.h
index ff756035c..250b6dc49 100644
--- a/source/core/slang-list.h
+++ b/source/core/slang-list.h
@@ -52,6 +52,11 @@ namespace Slang
         {
             this->operator=(static_cast<List<T>&&>(list));
         }
+        List(ArrayView<T> view)
+            : List()
+        {
+            addRange(view);
+        }
         static List<T> makeRepeated(const T& val, Index count)
         {
             List<T> rs;
diff --git a/source/core/slang-short-list.h b/source/core/slang-short-list.h
index 5bad9faf8..adbb935e6 100644
--- a/source/core/slang-short-list.h
+++ b/source/core/slang-short-list.h
@@ -117,17 +117,17 @@ namespace Slang
             }
         };
 
-        Iterator begin()
+        Iterator begin() const
         {
             Iterator rs;
-            rs.container = this;
+            rs.container = const_cast<ThisType*>(this);
             rs.index = 0;
             return rs;
         }
-        Iterator end()
+        Iterator end() const
         {
             Iterator rs;
-            rs.container = this;
+            rs.container = const_cast<ThisType*>(this);
             rs.index = m_count;
             return rs;
         }
diff --git a/source/core/slang-token-reader.cpp b/source/core/slang-token-reader.cpp
index f6f29def3..e8ebfb9ec 100644
--- a/source/core/slang-token-reader.cpp
+++ b/source/core/slang-token-reader.cpp
@@ -416,7 +416,7 @@ namespace Misc {
                     tokenFlags |= TokenFlag::AtStartOfLine | TokenFlag::AfterWhitespace;
                     pos++;
                 }
-                else if (curChar == ' ' || curChar == '\t' || curChar == -62 || curChar == -96) // -62/-96:non-break space
+                else if (curChar == ' ' || curChar == '\t' || curChar == '\xC2' || curChar == '\xA0') // -62/-96:non-break space
                 {
                     tokenFlags |= TokenFlag::AfterWhitespace;
                     pos++;
diff --git a/source/slang/core.meta.slang b/source/slang/core.meta.slang
index ae70a83f4..efd0a743c 100644
--- a/source/slang/core.meta.slang
+++ b/source/slang/core.meta.slang
@@ -316,7 +316,7 @@ interface __FlagsEnumType : __EnumType
 };
 
 __generic<T, let N:int>
-__magic_type(ArrayType)
+__magic_type(ArrayExpressionType)
 struct Array
 {
 }
@@ -876,7 +876,7 @@ extension int16_t
 
     /// An `N` component vector with elements of type `T`.
 __generic<T = float, let N : int = 4>
-__magic_type(Vector)
+__magic_type(VectorExpressionType)
 struct vector
 {
         /// The element type of the vector
@@ -896,7 +896,7 @@ struct vector
 
     /// A matrix with `R` rows and `C` columns, with elements of type `T`.
 __generic<T = float, let R : int = 4, let C : int = 4>
-__magic_type(Matrix)
+__magic_type(MatrixExpressionType)
 struct matrix
 {
     __intrinsic_op($(kIROp_MakeMatrixFromScalar))
@@ -957,12 +957,12 @@ for (int tt = 0; tt < kTypeCount; ++tt)
 
 __generic<T>
 __intrinsic_type($(kIROp_ConstantBufferType))
-__magic_type(ConstantBuffer)
+__magic_type(ConstantBufferType)
 struct ConstantBuffer {}
 
 __generic<T>
 __intrinsic_type($(kIROp_TextureBufferType))
-__magic_type(TextureBuffer)
+__magic_type(TextureBufferType)
 struct TextureBuffer {}
 
 __generic<T>
@@ -1238,14 +1238,14 @@ extension matrix<T, R, C> : IDifferentiable
 //@ public:
 
     /// Sampling state for filtered texture fetches.
-__magic_type(SamplerState, $(int(SamplerStateFlavor::SamplerState)))
+__magic_type(SamplerStateType, $(int(SamplerStateFlavor::SamplerState)))
 __intrinsic_type($(kIROp_SamplerStateType))
 struct SamplerState
 {
 }
 
     /// Sampling state for filtered texture fetches that include a comparison operation before filtering.
-__magic_type(SamplerState, $(int(SamplerStateFlavor::SamplerComparisonState)))
+__magic_type(SamplerStateType, $(int(SamplerStateFlavor::SamplerComparisonState)))
 __intrinsic_type($(kIROp_SamplerComparisonStateType))
 struct SamplerComparisonState
 {
@@ -1347,12 +1347,12 @@ struct TextureTypeInfo
             
         if(prefixInfo.combined)
         {
-            sb << "__magic_type(TextureSampler," << int(flavor) << ")\n";
+            sb << "__magic_type(TextureSamplerType," << int(flavor) << ")\n";
             sb << "__intrinsic_type(" << (kIROp_TextureSamplerType + (int(flavor) << kIROpMeta_OtherShift)) << ")\n";
         }
         else
         {
-            sb << "__magic_type(Texture," << int(flavor) << ")\n";
+            sb << "__magic_type(TextureType," << int(flavor) << ")\n";
             sb << "__intrinsic_type(" << (kIROp_TextureType + (int(flavor) << kIROpMeta_OtherShift)) << ")\n";
         }
         sb << "struct ";
diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang
index 9716a3e9e..1ab046b19 100644
--- a/source/slang/hlsl.meta.slang
+++ b/source/slang/hlsl.meta.slang
@@ -5048,7 +5048,7 @@ for (int aa = 0; aa < kBaseBufferAccessLevelCount; ++aa)
     bool isReadOnly = (access == SLANG_RESOURCE_ACCESS_READ);
     auto flavor = TextureFlavor::create(TextureFlavor::Shape::ShapeBuffer, access).flavor;
     sb << "__generic<T>\n";
-    sb << "__magic_type(Texture," << int(flavor) << ")\n";
+    sb << "__magic_type(TextureType," << int(flavor) << ")\n";
     sb << "__intrinsic_type(" << (kIROp_TextureType + (int(flavor) << kIROpMeta_OtherShift)) << ")\n";
     sb << "struct ";
     sb << kBaseBufferAccessLevels[aa].name;
@@ -5566,7 +5566,7 @@ static const int feedbackTexture2DFlavor = int(TextureFlavor::create(TextureFlav
 static const int feedbackTexture2DArrayFlavor = int(TextureFlavor::create(TextureFlavor::Shape::Shape2D, SLANG_RESOURCE_ACCESS_WRITE, SLANG_TEXTURE_FEEDBACK_FLAG | SLANG_TEXTURE_ARRAY_FLAG).flavor);
 }}}}
 
-__magic_type(Texture, $(feedbackTexture2DFlavor))
+__magic_type(TextureType, $(feedbackTexture2DFlavor))
 __intrinsic_type($(kIROp_TextureType + (feedbackTexture2DFlavor << kIROpMeta_OtherShift)))
 struct FeedbackTexture2D<T : __BuiltinSamplerFeedbackType>
 {
@@ -5619,7 +5619,7 @@ struct FeedbackTexture2D<T : __BuiltinSamplerFeedbackType>
 
 
 
-__magic_type(Texture, $(feedbackTexture2DArrayFlavor))
+__magic_type(TextureType, $(feedbackTexture2DArrayFlavor))
 __intrinsic_type($(kIROp_TextureType + (feedbackTexture2DArrayFlavor << kIROpMeta_OtherShift)))
 struct FeedbackTexture2DArray<T : __BuiltinSamplerFeedbackType>
 {
diff --git a/source/slang/slang-ast-base.cpp b/source/slang/slang-ast-base.cpp
new file mode 100644
index 000000000..0ad2bb101
--- /dev/null
+++ b/source/slang/slang-ast-base.cpp
@@ -0,0 +1,33 @@
+#include "slang-ast-base.h"
+#include "slang-ast-builder.h"
+
+namespace Slang
+{
+void NodeBase::_initDebug(ASTNodeType inAstNodeType, ASTBuilder* inAstBuilder)
+{
+#ifdef _DEBUG
+    SLANG_UNUSED(inAstNodeType);
+    static int32_t uidCounter = 0;
+    static int32_t breakValue = 0;
+    uidCounter++;
+    _debugUID = uidCounter;
+    if (inAstBuilder->getId() == -1)
+        _debugUID = -_debugUID;
+    if (breakValue != 0 && _debugUID == breakValue)
+        SLANG_BREAKPOINT(0)
+#else
+    SLANG_UNUSED(inAstNodeType);
+    SLANG_UNUSED(inAstBuilder);
+#endif
+}
+DeclRefBase* Decl::getDefaultDeclRef()
+{
+    auto astBuilder = getCurrentASTBuilder();
+    if (astBuilder->getEpoch() != m_defaultDeclRefEpoch || !m_defaultDeclRef)
+    {
+        m_defaultDeclRef = astBuilder->getDirectDeclRef(this);
+        m_defaultDeclRefEpoch = astBuilder->getEpoch();
+    }
+    return m_defaultDeclRef;
+}
+}
diff --git a/source/slang/slang-ast-base.h b/source/slang/slang-ast-base.h
index b90014316..d8f4c8c6c 100644
--- a/source/slang/slang-ast-base.h
+++ b/source/slang/slang-ast-base.h
@@ -16,25 +16,26 @@
 namespace Slang
 {  
 
+class ASTBuilder;
+struct SemanticsVisitor;
+
 class NodeBase 
 {
     SLANG_ABSTRACT_AST_CLASS(NodeBase)
 
         // MUST be called before used. Called automatically via the ASTBuilder.
         // Note that the astBuilder is not stored in the NodeBase derived types by default.
-    SLANG_FORCE_INLINE void init(ASTNodeType inAstNodeType, ASTBuilder* /*astBuilder*/)
+    SLANG_FORCE_INLINE void init(ASTNodeType inAstNodeType, ASTBuilder* inAstBuilder)
     {
+        SLANG_UNUSED(inAstBuilder);
         astNodeType = inAstNodeType;
 #ifdef _DEBUG
-        static uint32_t uidCounter = 0;
-        static uint32_t breakValue = 0;
-        uidCounter++;
-        _debugUID = uidCounter;
-        if (breakValue != 0 && _debugUID == breakValue)
-            SLANG_BREAKPOINT(0)
+        _initDebug(inAstNodeType, inAstBuilder);
 #endif
     }
 
+    void _initDebug(ASTNodeType inAstNodeType, ASTBuilder* inAstBuilder);
+
         /// Get the class info 
     SLANG_FORCE_INLINE const ReflectClassInfo& getClassInfo() const { return *ASTClassInfo::getInfo(astNodeType); }
 
@@ -48,7 +49,7 @@ class NodeBase
     // Handy when debugging, shouldn't be checked in though!
     // virtual ~NodeBase() {}
 #ifdef _DEBUG
-    SLANG_UNREFLECTED uint32_t _debugUID = 0;
+    SLANG_UNREFLECTED int32_t _debugUID = 0;
 #endif
 };
 
@@ -82,7 +83,14 @@ SLANG_FORCE_INLINE const T* as(const NodeBase* node)
 // to avoid confusion and bugs. Instead, use the `as<>()` method on `DeclRefBase` to
 // get a `DeclRef<T>` for a specific node type.
 template<typename T>
-T* as(const DeclRefBase* declRefBase) = delete;
+T* as(DeclRefBase* declRefBase, typename EnableIf<!IsBaseOf<DeclRefBase, T>::Value, void*>::type arg = nullptr) = delete;
+
+template<typename T>
+T* as(DeclRefBase* declRefBase, typename EnableIf<IsBaseOf<DeclRefBase, T>::Value, void*>::type arg = nullptr)
+{
+    SLANG_UNUSED(arg);
+    return dynamicCast<T>(declRefBase);
+}
 
 template<typename T, typename U>
 DeclRef<T> as(DeclRef<U> declRef) { return DeclRef<T>(declRef); }
@@ -116,6 +124,177 @@ class SyntaxNodeBase : public NodeBase
     SourceLoc loc;
 };
 
+enum class ValNodeOperandKind
+{
+    ConstantValue,
+    ValNode,
+    ASTNode,
+};
+
+struct ValNodeOperand
+{
+    ValNodeOperandKind kind = ValNodeOperandKind::ConstantValue;
+    union
+    {
+        NodeBase* nodeOperand;
+        int64_t intOperand;
+    } values;
+
+    ValNodeOperand()
+    {
+        values.nodeOperand = nullptr;
+    }
+
+    explicit ValNodeOperand(NodeBase* node)
+    {
+        if (as<Val>(node))
+        {
+            values.nodeOperand = (NodeBase*)node;
+            kind = ValNodeOperandKind::ValNode;
+        }
+        else
+        {
+            values.nodeOperand = node;
+            kind = ValNodeOperandKind::ASTNode;
+        }
+    }
+
+    template<typename T>
+    explicit ValNodeOperand(DeclRef<T> declRef) { values.nodeOperand = declRef.declRefBase; kind = ValNodeOperandKind::ValNode; }
+
+    template<typename T>
+    explicit ValNodeOperand(T* node)
+    {
+        if constexpr (std::is_base_of<Val, T>::value)
+        {
+            values.nodeOperand = (NodeBase*)node;
+            kind = ValNodeOperandKind::ValNode;
+        }
+        else if constexpr (std::is_base_of<NodeBase, T>::value)
+        {
+            values.nodeOperand = node;
+            kind = ValNodeOperandKind::ASTNode;
+        }
+        else
+        {
+            static_assert(std::is_base_of<Val, T>::value || std::is_base_of<NodeBase, T>::value, "pointer used as Val operand must be an AST node.");
+        }
+    }
+
+    template<typename EnumType>
+    explicit ValNodeOperand(EnumType intVal)
+    {
+        static_assert(std::is_trivial<EnumType>::value, "Type to construct NodeOperand must be trivial.");
+        static_assert(sizeof(EnumType) <= sizeof(values), "size of operand must be less than pointer size.");
+        values.intOperand = 0;
+        memcpy(&values, &intVal, sizeof(intVal));
+        kind = ValNodeOperandKind::ConstantValue;
+    }
+};
+
+struct ValNodeDesc
+{
+    ASTNodeType             type;
+    ShortList<ValNodeOperand, 4> operands;
+
+    bool operator==(ValNodeDesc const& that) const;
+    HashCode getHashCode() const { return hashCode; }
+    void init();
+private:
+    HashCode hashCode = 0;
+};
+
+template<int N>
+static void addOrAppendToNodeList(ShortList<ValNodeOperand, N>&)
+{}
+
+template<int N, typename... Ts>
+static void addOrAppendToNodeList(ShortList<ValNodeOperand, N>& list, ExpandedSpecializationArgs e, Ts... ts)
+{
+    for (auto arg : e)
+    {
+        list.add(ValNodeOperand(arg.val));
+        list.add(ValNodeOperand(arg.witness));
+    }
+    addOrAppendToNodeList(list, ts...);
+}
+
+template<int N, typename T, typename... Ts>
+static void addOrAppendToNodeList(ShortList<ValNodeOperand, N>& list, T t, Ts... ts)
+{
+    list.add(ValNodeOperand(t));
+    addOrAppendToNodeList(list, ts...);
+}
+
+template<int N, typename T, typename... Ts>
+static void addOrAppendToNodeList(ShortList<ValNodeOperand, N>& list, const List<T>& l, Ts... ts)
+{
+    for (auto t : l)
+        list.add(ValNodeOperand(t));
+    addOrAppendToNodeList(list, ts...);
+}
+
+template<int N, typename T, typename... Ts>
+static void addOrAppendToNodeList(ShortList<ValNodeOperand, N>& list, ConstArrayView<T> l, Ts... ts)
+{
+    for (auto t : l)
+        list.add(ValNodeOperand(t));
+    addOrAppendToNodeList(list, ts...);
+}
+
+template<int N, typename T, typename... Ts>
+static void addOrAppendToNodeList(ShortList<ValNodeOperand, N>& list, ArrayView<T> l, Ts... ts)
+{
+    for (auto t : l)
+        list.add(ValNodeOperand(t));
+    addOrAppendToNodeList(list, ts...);
+}
+
+inline void addOrAppendToNodeList(List<ValNodeOperand>&)
+{}
+
+template<typename... Ts>
+static void addOrAppendToNodeList(List<ValNodeOperand>& list, ExpandedSpecializationArgs e, Ts... ts)
+{
+    for (auto arg : e)
+    {
+        list.add(ValNodeOperand(arg.val));
+        list.add(ValNodeOperand(arg.witness));
+    }
+    addOrAppendToNodeList(list, ts...);
+}
+
+template<typename T, typename... Ts>
+static void addOrAppendToNodeList(List<ValNodeOperand>& list, T t, Ts... ts)
+{
+    list.add(ValNodeOperand(t));
+    addOrAppendToNodeList(list, ts...);
+}
+
+template<typename T, typename... Ts>
+static void addOrAppendToNodeList(List<ValNodeOperand>& list, const List<T>& l, Ts... ts)
+{
+    for (auto t : l)
+        list.add(ValNodeOperand(t));
+    addOrAppendToNodeList(list, ts...);
+}
+
+template<typename T, typename... Ts>
+static void addOrAppendToNodeList(List<ValNodeOperand>& list, ConstArrayView<T> l, Ts... ts)
+{
+    for (auto t : l)
+        list.add(ValNodeOperand(t));
+    addOrAppendToNodeList(list, ts...);
+}
+
+template<typename T, typename... Ts>
+static void addOrAppendToNodeList(List<ValNodeOperand>& list, ArrayView<T> l, Ts... ts)
+{
+    for (auto t : l)
+        list.add(ValNodeOperand(t));
+    addOrAppendToNodeList(list, ts...);
+}
+
 // Base class for compile-time values (most often a type).
 // These are *not* syntax nodes, because they do not have
 // a unique location, and any two `Val`s representing
@@ -124,6 +303,54 @@ class SyntaxNodeBase : public NodeBase
 class Val : public NodeBase
 {
     SLANG_ABSTRACT_AST_CLASS(Val)
+    
+    template<typename T>
+    struct OperandView
+    {
+        const Val* val;
+        Index offset;
+        Index count;
+        OperandView()
+        {
+            val = nullptr;
+            offset = 0;
+            count = 0;
+        }
+        OperandView(const Val* val, Index offset, Index count) : val(val), offset(offset), count(count) {}
+        Index getCount() { return count; }
+        T* operator[](Index index) const
+        {
+            return as<T>(val->getOperand(index + offset));
+        }
+        struct Iterator
+        {
+            const Val* val;
+            Index i;
+            bool operator==(Iterator other) const
+            {
+                return val == other.val && i == other.i;
+            }
+            bool operator!=(Iterator other) const
+            {
+                return val != other.val || i != other.i;
+            }
+            T*& operator*() const
+            {
+                return *(T**)&val->m_operands[i].values.nodeOperand;
+            }
+            T** operator->() const
+            {
+                return (T**)&val->m_operands[i].values.nodeOperand;
+            }
+            Iterator& operator++()
+            {
+                i++;
+                return *this;
+            }
+        };
+        Iterator begin() const { return Iterator { val, offset }; }
+        Iterator end() const { return Iterator{ val, offset + count }; }
+    };
 
     typedef IValVisitor Visitor;
 
@@ -140,25 +367,84 @@ class Val : public NodeBase
     // decide whether they need to do anything).
     Val* substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 
-    bool equalsVal(Val* val);
+    bool equals(Val* val) const
+    {
+        return this == val || const_cast<Val*>(this)->resolve() == val->resolve();
+    }
 
     // Appends as text to the end of the builder
     void toText(StringBuilder& out);
     String toString();
 
     HashCode getHashCode();
-    bool operator == (const Val & v)
+    bool operator == (const Val & v) const
     {
-        return equalsVal(const_cast<Val*>(&v));
+        return equals(const_cast<Val*>(&v));
     }
 
     // Overrides should be public so base classes can access
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
+
+    Val* _resolveImplOverride();
+
+    Val* resolveImpl();
+    Val* resolve();
+    ValNodeDesc getDesc();
+
+    Val* getOperand(Index index) const
+    {
+        SLANG_ASSERT(m_operands[index].kind == ValNodeOperandKind::ValNode);
+        return (Val*)m_operands[index].values.nodeOperand;
+    }
+
+    Decl* getDeclOperand(Index index) const
+    {
+        SLANG_ASSERT(m_operands[index].kind == ValNodeOperandKind::ASTNode);
+        return (Decl*)(m_operands[index].values.nodeOperand);
+    }
+
+    int64_t getIntConstOperand(Index index) const
+    {
+        SLANG_ASSERT(m_operands[index].kind == ValNodeOperandKind::ConstantValue);
+        return m_operands[index].values.intOperand;
+    }
+
+    Index getOperandCount() const { return m_operands.getCount(); }
+
+    template<typename ... TArgs>
+    void setOperands(TArgs... args)
+    {
+        m_operands.clear();
+        addOrAppendToNodeList(m_operands, args...);
+    }
+    template<typename ... TArgs>
+    void addOperands(TArgs... args)
+    {
+        addOrAppendToNodeList(m_operands, args...);
+    }
+    template<typename T>
+    void addOperands(OperandView<T> operands)
+    {
+        for (auto v : operands)
+            m_operands.add(ValNodeOperand(v));
+    }
+    List<ValNodeOperand> m_operands;
+protected:
+    Val* defaultResolveImpl();
+private:
+    mutable Val* m_resolvedVal = nullptr;
+    SLANG_UNREFLECTED mutable Index m_resolvedValEpoch = 0;
 };
 
+template<int N, typename T, typename... Ts>
+static void addOrAppendToNodeList(ShortList<ValNodeOperand, N>& list, Val::OperandView<T> l, Ts... ts)
+{
+    for (auto t : l)
+        list.add(ValNodeOperand(t));
+    addOrAppendToNodeList(list, ts...);
+}
+
 struct ValSet
 {
     struct ValItem
@@ -176,9 +462,9 @@ struct ValSet
             if (val == other.val)
                 return true;
             if (val)
-                return val->equalsVal(other.val);
+                return val->equals(other.val);
             else if (other.val)
-                return other.val->equalsVal(val);
+                return other.val->equals(val);
             return false;
         }
     };
@@ -232,31 +518,32 @@ class Type: public Val
 
         /// Type derived types store the AST builder they were constructed on. The builder calls this function
         /// after constructing.
-    SLANG_FORCE_INLINE void init(ASTNodeType inAstNodeType, ASTBuilder* inAstBuilder) { Val::init(inAstNodeType, inAstBuilder); m_astBuilder = inAstBuilder; }
-
-        /// Get the ASTBuilder that was used to construct this Type
-    SLANG_FORCE_INLINE ASTBuilder* getASTBuilder() const { return m_astBuilder; }
-
-    bool equals(Type* type);
-    
-    Type* getCanonicalType();
+    SLANG_FORCE_INLINE void init(ASTNodeType inAstNodeType, ASTBuilder* inAstBuilder)
+    {
+        Val::init(inAstNodeType, inAstBuilder);
+        m_astBuilderForReflection = inAstBuilder;
+    }
 
     // Overrides should be public so base classes can access
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
-    bool _equalsValOverride(Val* val);
-    bool _equalsImplOverride(Type* type);
     Type* _createCanonicalTypeOverride();
+    Val* _resolveImplOverride();
 
-    void _setASTBuilder(ASTBuilder* astBuilder) { m_astBuilder = astBuilder; }
+    Type* getCanonicalType()
+    {
+        return as<Type>(resolve());
+    }
 
+    ASTBuilder* getASTBuilderForReflection() const { return m_astBuilderForReflection; }
 protected:
-    bool equalsImpl(Type* type);
     Type* createCanonicalType();
 
-    Type* canonicalType = nullptr;
-
-    SLANG_UNREFLECTED
-    ASTBuilder* m_astBuilder = nullptr;
+    // We store the ASTBuilder to support reflection API only.
+    // It should not be used for anything else, especially not for constructing new AST nodes during
+    // semantic checking, since Val deduplication requires the entire semantic checking process to
+    // stick with one ASTBuilder.
+    // Call getCurrentASTBuilder() to obtain the right ASTBuilder for semantic checking.
+    SLANG_UNREFLECTED ASTBuilder* m_astBuilderForReflection;
 };
 
 template <typename T>
@@ -264,161 +551,68 @@ SLANG_FORCE_INLINE T* as(Type* obj) { return obj ? dynamicCast<T>(obj->getCanoni
 template <typename T>
 SLANG_FORCE_INLINE const T* as(const Type* obj) { return obj ? dynamicCast<T>(const_cast<Type*>(obj)->getCanonicalType()) : nullptr; }
 
-// A substitution represents a binding of certain
-// type-level variables to concrete argument values
-class Substitutions: public NodeBase
-{
-    SLANG_ABSTRACT_AST_CLASS(Substitutions)
-
-
-    // Apply a set of substitutions to the bindings in this substitution
-    Substitutions* applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff);
-
-    // Check if these are equivalent substitutions to another set
-    bool equals(Substitutions* subst);
-    HashCode getHashCode() const;
-
-    // Overrides should be public so base classes can access
-    Substitutions* _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff);
-    bool _equalsOverride(Substitutions* subst);
-    HashCode _getHashCodeOverride() const;
-
-    Substitutions* getOuter() const { return outer; }
-protected:
-    // The next outer that this one refines.
-    Substitutions* outer = nullptr;
-};
-
-class GenericSubstitution : public Substitutions
-{
-    SLANG_AST_CLASS(GenericSubstitution)
-
-private:
-    // The generic declaration that defines the
-    // parameters we are binding to arguments
-    GenericDecl* genericDecl = nullptr;
-
-    // The actual values of the arguments
-    List<Val* > args;
-public:
-    GenericDecl* getGenericDecl() const { return genericDecl; }
-    List<Val*>& getArgs() { return args; }
-    const List<Val*>& getArgs() const { return args; }
-
-    // Overrides should be public so base classes can access
-    Substitutions* _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff);
-    bool _equalsOverride(Substitutions* subst);
-    HashCode _getHashCodeOverride() const;
-
-    GenericSubstitution(Substitutions* outerSubst, GenericDecl* decl, ArrayView<Val*> argVals)
-    {
-        outer = outerSubst;
-        genericDecl = decl;
-        args.addRange(argVals);
-    }
-};
-
-class ThisTypeSubstitution : public Substitutions
-{
-    SLANG_AST_CLASS(ThisTypeSubstitution)
-
-    // The declaration of the interface that we are specializing
-    InterfaceDecl* interfaceDecl = nullptr;
-
-    // A witness that shows that the concrete type used to
-    // specialize the interface conforms to the interface.
-    SubtypeWitness* witness = nullptr;
-
-    // Overrides should be public so base classes can access
-    // The actual type that provides the lookup scope for an associated type
-    Substitutions* _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff);
-    bool _equalsOverride(Substitutions* subst);
-    HashCode _getHashCodeOverride() const;
-
-    ThisTypeSubstitution(Substitutions* outerSubst, InterfaceDecl* inInterfaceDecl, SubtypeWitness* inWitness)
-        : interfaceDecl(inInterfaceDecl), witness(inWitness)
-    {
-        outer = outerSubst;
-    }
-};
-
 class Decl;
 
 // A reference to a declaration, which may include
 // substitutions for generic parameters.
 class DeclRefBase : public Val
 {
-    SLANG_AST_CLASS(DeclRefBase)
+    SLANG_ABSTRACT_AST_CLASS(DeclRefBase)
 
-    Decl* getDecl() const { return decl; }
+    Decl* getDecl() const { return getDeclOperand(0); }
 
-    Substitutions* getSubst() const { return substitutions; }
+    // Apply substitutions to this declaration reference
+    DeclRefBase* substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 
-    DeclRefBase(Decl* decl)
-        :decl(decl)
+    DeclRefBase* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
     {
+        SLANG_UNUSED(astBuilder);
+        SLANG_UNUSED(subst);
+        SLANG_UNUSED(ioDiff);
+        SLANG_UNREACHABLE("DeclRefBase::_substituteImplOverride not overrided.");
     }
 
-    DeclRefBase(Decl* decl, Substitutions* subst)
-        :decl(decl), substitutions(subst)
+    void _toTextOverride(StringBuilder& out)
     {
+        SLANG_UNUSED(out);
+        SLANG_UNREACHABLE("DeclRefBase::_toTextOverride not overrided.");
     }
 
-    // Apply substitutions to a type or declaration
-    Type* substitute(ASTBuilder* astBuilder, Type* type) const;
-
-    DeclRefBase* substitute(ASTBuilder* astBuilder, DeclRefBase* declRef) const;
-
-    // Apply substitutions to an expression
-    SubstExpr<Expr> substitute(ASTBuilder* astBuilder, Expr* expr) const;
-
-    // Apply substitutions to this declaration reference
-    DeclRefBase* substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) const;
-
-    Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
+    Val* _resolveImplOverride()
     {
-        return substituteImpl(astBuilder, subst, ioDiff);
+        SLANG_UNREACHABLE("DeclRefBase::_resolveImplOverride not overrided.");
     }
-    bool _equalsValOverride(Val* val);
-
-    bool _equalsImplOverride(DeclRefBase* declRef) { return equals(declRef); }
 
-    void _toTextOverride(StringBuilder& out) { toText(out); }
+    DeclRefBase* _getBaseOverride()
+    {
+        SLANG_UNREACHABLE("DeclRefBase::_getBaseOverride not overrided.");
+    }
 
     // Returns true if 'as' will return a valid cast
     template <typename T>
-    bool is() const { return Slang::as<T>(decl) != nullptr; }
-
-    // Check if this is an equivalent declaration reference to another
-    bool equals(DeclRefBase* declRef) const;
+    bool is() const { return Slang::as<T>(getDecl()) != nullptr; }
 
     // Convenience accessors for common properties of declarations
     Name* getName() const;
     SourceLoc getNameLoc() const;
     SourceLoc getLoc() const;
-    DeclRefBase* getParent(ASTBuilder* astBuilder) const;
-
-    HashCode getHashCode() const;
-
-    // Debugging:
-    String toString() const;
-    void toText(StringBuilder& out) const;
-
-private:
-
-    // The underlying declaration
-    Decl* decl = nullptr;
-    // Optionally, a chain of substitutions to perform
-    Substitutions* substitutions = nullptr;
-
+    DeclRefBase* getParent();
+    String toString() const
+    {
+        StringBuilder sb;
+        const_cast<DeclRefBase*>(this)->toText(sb);
+        return sb.produceString();
+    }
+    DeclRefBase* getBase();
+    void toText(StringBuilder& out);
 };
 
-SLANG_FORCE_INLINE StringBuilder& operator<<(StringBuilder& io, const DeclRefBase* declRef) { declRef->toText(io); return io; }
+SLANG_FORCE_INLINE StringBuilder& operator<<(StringBuilder& io, const DeclRefBase* declRef) { if (declRef) const_cast<DeclRefBase*>(declRef)->toText(io); return io; }
 
-SLANG_FORCE_INLINE StringBuilder& operator<<(StringBuilder& io, const Decl* decl)
+SLANG_FORCE_INLINE StringBuilder& operator<<(StringBuilder& io, Decl* decl)
 {
     if (decl)
-        _printNestedDecl(nullptr, decl, io);
+        makeDeclRef(decl).declRefBase->toText(io);
     return io;
 }
 
@@ -488,12 +682,7 @@ public:
 
     ContainerDecl* parentDecl = nullptr;
 
-    // A direct DeclRef to this Decl.
-    // For every Decl, we create a DeclRef node representing a direct reference to it
-    // upon the creation of the Decl (implemented in ASTBuilder), and store that
-    // DeclRef here so we can get a direct DeclRef from a Decl* (by calling makeDeclRef)
-    // without requiring a ASTBuilder to be available.
-    DeclRefBase* defaultDeclRef = nullptr;
+    DeclRefBase* getDefaultDeclRef();
 
     NameLoc nameAndLoc;
 
@@ -514,6 +703,10 @@ public:
         SLANG_RELEASE_ASSERT(state >= checkState.getState());
         checkState.setState(state);
     }
+
+private:
+    SLANG_UNREFLECTED DeclRefBase* m_defaultDeclRef = nullptr;
+    SLANG_UNREFLECTED Index m_defaultDeclRefEpoch = -1;
 };
 
 class Expr : public SyntaxNode
@@ -551,8 +744,7 @@ DeclRef<T>::DeclRef(Decl* decl)
     DeclRefBase* declRef = nullptr;
     if (decl)
     {
-        SLANG_ASSERT(decl->defaultDeclRef);
-        declRef = decl->defaultDeclRef;
+        declRef = decl->getDefaultDeclRef();
     }
     init(declRef);
 }
@@ -564,12 +756,6 @@ T* DeclRef<T>::getDecl() const
 }
 
 template<typename T>
-Substitutions* DeclRef<T>::getSubst() const
-{
-    return declRefBase ? declRefBase->getSubst() : nullptr;
-}
-
-template<typename T>
 Name* DeclRef<T>::getName() const
 {
     if (declRefBase)
@@ -592,9 +778,9 @@ SourceLoc DeclRef<T>::getLoc() const
 }
 
 template<typename T>
-DeclRef<ContainerDecl> DeclRef<T>::getParent(ASTBuilder* astBuilder) const
+DeclRef<ContainerDecl> DeclRef<T>::getParent() const
 {
-    if (declRefBase) return DeclRef<ContainerDecl>(declRefBase->getParent(astBuilder));
+    if (declRefBase) return DeclRef<ContainerDecl>(declRefBase->getParent());
     return DeclRef<ContainerDecl>((DeclRefBase*)nullptr);
 }
 
@@ -608,15 +794,17 @@ HashCode DeclRef<T>::getHashCode() const
 template<typename T>
 Type* DeclRef<T>::substitute(ASTBuilder* astBuilder, Type* type) const
 {
+    SLANG_UNUSED(astBuilder);
     if (!declRefBase) return type;
-    return declRefBase->substitute(astBuilder, type);
+    return SubstitutionSet(*this).applyToType(astBuilder, type);
 }
 
 template<typename T>
 SubstExpr<Expr> DeclRef<T>::substitute(ASTBuilder* astBuilder, Expr* expr) const
 {
+    SLANG_UNUSED(astBuilder);
     if (!declRefBase) return expr;
-    return declRefBase->substitute(astBuilder, expr);
+    return applySubstitutionToExpr(SubstitutionSet(*this), expr);
 }
 
 // Apply substitutions to a type or declaration
@@ -624,23 +812,21 @@ template<typename T>
 template<typename U>
 DeclRef<U> DeclRef<T>::substitute(ASTBuilder* astBuilder, DeclRef<U> declRef) const
 {
+    SLANG_UNUSED(astBuilder);
     if (!declRefBase) return declRef;
-    return DeclRef<U>(declRefBase->substitute(astBuilder, declRef.declRefBase));
+    return DeclRef<U>(SubstitutionSet(*this).applyToDeclRef(astBuilder, declRef.declRefBase));
 }
 
 // Apply substitutions to this declaration reference
 template<typename T>
 DeclRef<T> DeclRef<T>::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) const
 {
+    SLANG_UNUSED(astBuilder);
     if (!declRefBase) return *this;
     return DeclRef<T>(declRefBase->substituteImpl(astBuilder, subst, ioDiff));
 }
 
-template<typename T>
-template<typename U>
-bool DeclRef<T>::equals(DeclRef<U> other) const
-{
-    return declRefBase == other.declRefBase || (declRefBase && declRefBase->equals(other.declRefBase));
-}
+Val::OperandView<Val> tryGetGenericArguments(SubstitutionSet substSet, Decl* genericDecl);
+
 
 } // namespace Slang
diff --git a/source/slang/slang-ast-builder.cpp b/source/slang/slang-ast-builder.cpp
index 64a7abd8c..96fb6ac79 100644
--- a/source/slang/slang-ast-builder.cpp
+++ b/source/slang/slang-ast-builder.cpp
@@ -29,12 +29,6 @@ void SharedASTBuilder::init(Session* session)
     // Clear the built in types
     memset(m_builtinTypes, 0, sizeof(m_builtinTypes));
 
-    // Create common shared types
-    m_errorType = m_astBuilder->create<ErrorType>();
-    m_bottomType = m_astBuilder->create<BottomType>();
-    m_initializerListType = m_astBuilder->create<InitializerListType>();
-    m_overloadedType = m_astBuilder->create<OverloadGroupType>();
-
     // We can just iterate over the class pointers.
     // NOTE! That this adds the names of the abstract classes too(!)
     for (Index i = 0; i < Index(ASTNodeType::CountOf); ++i)
@@ -151,6 +145,31 @@ Type* SharedASTBuilder::getDiffInterfaceType()
     return m_diffInterfaceType;
 }
 
+Type* SharedASTBuilder::getErrorType()
+{
+    if (!m_errorType)
+        m_errorType = m_astBuilder->getOrCreate<ErrorType>();
+    return m_errorType;
+}
+Type* SharedASTBuilder::getBottomType()
+{
+    if (!m_bottomType)
+        m_bottomType = m_astBuilder->getOrCreate<BottomType>();
+    return m_bottomType;
+}
+Type* SharedASTBuilder::getInitializerListType()
+{
+    if (!m_initializerListType)
+        m_initializerListType = m_astBuilder->getOrCreate<InitializerListType>();
+    return m_initializerListType;
+}
+Type* SharedASTBuilder::getOverloadedType()
+{
+    if (!m_overloadedType)
+        m_overloadedType = m_astBuilder->getOrCreate<OverloadGroupType>();
+    return m_overloadedType;
+}
+
 SharedASTBuilder::~SharedASTBuilder()
 {
     // Release built in types..
@@ -208,19 +227,28 @@ Decl* SharedASTBuilder::tryFindMagicDecl(const String& name)
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ASTBuilder !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
+Index& _getGlobalASTEpochId()
+{
+    static thread_local Index epochId = 1;
+    return epochId;
+}
+
 ASTBuilder::ASTBuilder(SharedASTBuilder* sharedASTBuilder, const String& name):
     m_sharedASTBuilder(sharedASTBuilder),
     m_name(name),
     m_id(sharedASTBuilder->m_id++),
-    m_arena(2048)
+    m_arena(2097152)
 {
     SLANG_ASSERT(sharedASTBuilder);
+    // Copy Val deduplication map over so we don't create duplicate Vals that are already
+    // existent in the stdlib.
+    m_cachedNodes = sharedASTBuilder->getInnerASTBuilder()->m_cachedNodes;
 }
 
 ASTBuilder::ASTBuilder():
     m_sharedASTBuilder(nullptr),
     m_id(-1),
-    m_arena(2048)
+    m_arena(2097152)
 {
     m_name = "SharedASTBuilder::m_astBuilder";
 }
@@ -233,6 +261,25 @@ ASTBuilder::~ASTBuilder()
         SLANG_ASSERT(info->m_destructorFunc);
         info->m_destructorFunc(node);
     }
+    incrementEpoch();
+}
+
+Index ASTBuilder::getEpoch()
+{
+    return _getGlobalASTEpochId();
+}
+
+void ASTBuilder::incrementEpoch()
+{
+    _getGlobalASTEpochId()++;
+}
+
+void ASTBuilder::_verifyValDescConsistency(Val* val, const ValNodeDesc& expectedDesc)
+{
+    if (!val)
+        return;
+    ValNodeDesc descOut = val->getDesc();
+    SLANG_ASSERT(descOut == expectedDesc);
 }
 
 NodeBase* ASTBuilder::createByNodeType(ASTNodeType nodeType)
@@ -256,6 +303,13 @@ Type* ASTBuilder::getSpecializedBuiltinType(Type* typeParam, char const* magicTy
     return rsType;
 }
 
+Type* ASTBuilder::getSpecializedBuiltinType(ArrayView<Val*> genericArgs, const char* magicTypeName)
+{
+    auto declRef = getBuiltinDeclRef(magicTypeName, genericArgs);
+    auto rsType = DeclRefType::create(this, declRef);
+    return rsType;
+}
+
 PtrType* ASTBuilder::getPtrType(Type* valueType)
 {
     return dynamicCast<PtrType>(getPtrType(valueType, "PtrType"));
@@ -292,64 +346,57 @@ ArrayExpressionType* ASTBuilder::getArrayType(Type* elementType, IntVal* element
 {
     if (!elementCount)
         elementCount = getIntVal(getIntType(), kUnsizedArrayMagicLength);
-
-    auto result = getOrCreate<ArrayExpressionType>(elementType, elementCount);
-    if (!result->declRef.getDecl())
+    if (elementCount->getType() != getIntType())
     {
-        auto arrayGenericDecl = as<GenericDecl>(m_sharedASTBuilder->findMagicDecl("ArrayType"));
-        auto arrayTypeDecl = arrayGenericDecl->inner;
-        auto substitutions = getOrCreateGenericSubstitution(nullptr, arrayGenericDecl, elementType, elementCount);
-        result->declRef = getSpecializedDeclRef<Decl>(arrayTypeDecl, substitutions);
+        // Canonicalize constant elementCount to int.
+        if (auto elementCountConstantInt = as<ConstantIntVal>(elementCount))
+        {
+            elementCount = getIntVal(getIntType(), elementCountConstantInt->getValue());
+        }
     }
-    return result;
+    Val* args[] = {elementType, elementCount};
+    return as<ArrayExpressionType>(getSpecializedBuiltinType(makeArrayView(args), "ArrayExpressionType"));
 }
 
 ConstantBufferType* ASTBuilder::getConstantBufferType(Type* elementType)
 {
-    auto result = getOrCreate<ConstantBufferType>(elementType);
-    if (!result->declRef.getDecl())
-    {
-        auto genericDecl = as<GenericDecl>(m_sharedASTBuilder->findMagicDecl("ConstantBuffer"));
-        auto typeDecl = genericDecl->inner;
-        auto substitutions = getOrCreateGenericSubstitution(nullptr, genericDecl, elementType);
-        result->declRef = getSpecializedDeclRef<Decl>(typeDecl, substitutions);
-    }
-    return result;
+    return as<ConstantBufferType>(getSpecializedBuiltinType(elementType, "ConstantBufferType"));
+}
+
+ParameterBlockType* ASTBuilder::getParameterBlockType(Type* elementType)
+{
+    return as<ParameterBlockType>(getSpecializedBuiltinType(elementType, "ParameterBlockType"));
+}
+
+HLSLStructuredBufferType* ASTBuilder::getStructuredBufferType(Type* elementType)
+{
+    return as<HLSLStructuredBufferType>(getSpecializedBuiltinType(elementType, "HLSLStructuredBufferType"));
+}
+
+SamplerStateType* ASTBuilder::getSamplerStateType()
+{
+    return as<SamplerStateType>(getSpecializedBuiltinType(nullptr, "HLSLStructuredBufferType"));
 }
 
 VectorExpressionType* ASTBuilder::getVectorType(
     Type*    elementType,
     IntVal*  elementCount)
 {
-    auto result = getOrCreate<VectorExpressionType>(elementType, elementCount);
-    if (!result->declRef.getDecl())
+    // Canonicalize constant elementCount to int.
+    if (auto elementCountConstantInt = as<ConstantIntVal>(elementCount))
     {
-        auto vectorGenericDecl = as<GenericDecl>(m_sharedASTBuilder->findMagicDecl("Vector"));
-        auto vectorTypeDecl = vectorGenericDecl->inner;
-        auto substitutions = getOrCreateGenericSubstitution(nullptr, vectorGenericDecl, elementType, elementCount);
-        result->declRef = getSpecializedDeclRef<Decl>(vectorTypeDecl, substitutions);
+        elementCount = getIntVal(getIntType(), elementCountConstantInt->getValue());
     }
-    return result;
+    Val* args[] = { elementType, elementCount };
+    return as<VectorExpressionType>(getSpecializedBuiltinType(makeArrayView(args), "VectorExpressionType"));
 }
 
 DifferentialPairType* ASTBuilder::getDifferentialPairType(
     Type* valueType,
     Witness* primalIsDifferentialWitness)
 {
-    auto genericDecl = dynamicCast<GenericDecl>(m_sharedASTBuilder->findMagicDecl("DifferentialPairType"));
-
-    auto typeDecl = genericDecl->inner;
-
-    auto substitutions = getOrCreateGenericSubstitution(
-        nullptr,
-        genericDecl,
-        valueType,
-        primalIsDifferentialWitness);
-
-    auto declRef = getSpecializedDeclRef<Decl>(typeDecl, substitutions);
-    auto rsType = DeclRefType::create(this, declRef);
-
-    return as<DifferentialPairType>(rsType);
+    Val* args[] = { valueType, primalIsDifferentialWitness };
+    return as<DifferentialPairType>(getSpecializedBuiltinType(makeArrayView(args), "DifferentialPairType"));
 }
 
 DeclRef<InterfaceDecl> ASTBuilder::getDifferentiableInterfaceDecl()
@@ -377,20 +424,9 @@ MeshOutputType* ASTBuilder::getMeshOutputTypeFromModifier(
         : as<HLSLIndicesModifier>(modifier) ? "IndicesType"
         : as<HLSLPrimitivesModifier>(modifier) ? "PrimitivesType"
         : (SLANG_UNEXPECTED("Unhandled mesh output modifier"), nullptr);
-    auto genericDecl = dynamicCast<GenericDecl>(m_sharedASTBuilder->findMagicDecl(declName));
-
-    auto typeDecl = genericDecl->inner;
-
-    auto substitutions = getOrCreateGenericSubstitution(
-        nullptr,
-        genericDecl,
-        elementType,
-        maxElementCount);
 
-    auto declRef = getSpecializedDeclRef<Decl>(typeDecl, substitutions);
-    auto rsType = DeclRefType::create(this, declRef);
-
-    return as<MeshOutputType>(rsType);
+    Val* args[] = { elementType, maxElementCount };
+    return as<MeshOutputType>(getSpecializedBuiltinType(makeArrayView(args), declName));
 }
 
 Type* ASTBuilder::getDifferentiableInterfaceType()
@@ -403,13 +439,8 @@ DeclRef<Decl> ASTBuilder::getBuiltinDeclRef(const char* builtinMagicTypeName, Va
     auto decl = m_sharedASTBuilder->findMagicDecl(builtinMagicTypeName);
     if (auto genericDecl = as<GenericDecl>(decl))
     {
-        decl = genericDecl->inner;
-        Substitutions* subst = nullptr;
-        if (genericArg)
-        {
-            subst = getOrCreateGenericSubstitution(nullptr, genericDecl, genericArg);
-        }
-        return getSpecializedDeclRef(decl, subst);
+        auto declRef = getGenericAppDeclRef(makeDeclRef(genericDecl), makeConstArrayViewSingle(genericArg));
+        return declRef;
     }
     else
     {
@@ -418,6 +449,21 @@ DeclRef<Decl> ASTBuilder::getBuiltinDeclRef(const char* builtinMagicTypeName, Va
     return makeDeclRef(decl);
 }
 
+DeclRef<Decl> ASTBuilder::getBuiltinDeclRef(const char* builtinMagicTypeName, ArrayView<Val*> genericArgs)
+{
+    auto decl = m_sharedASTBuilder->findMagicDecl(builtinMagicTypeName);
+    if (auto genericDecl = as<GenericDecl>(decl))
+    {
+        auto declRef = getGenericAppDeclRef(makeDeclRef(genericDecl), genericArgs);
+        return declRef;
+    }
+    else
+    {
+        SLANG_ASSERT(!decl && !genericArgs.getCount());
+    }
+    return makeDeclRef(decl);
+}
+
 Type* ASTBuilder::getAndType(Type* left, Type* right)
 {
     auto type = getOrCreate<AndType>(left, right);
@@ -426,9 +472,7 @@ Type* ASTBuilder::getAndType(Type* left, Type* right)
 
 Type* ASTBuilder::getModifiedType(Type* base, Count modifierCount, Val* const* modifiers)
 {
-    auto type = create<ModifiedType>();
-    type->base = base;
-    type->modifiers.addRange(modifiers, modifierCount);
+    auto type = getOrCreate<ModifiedType>(base, makeArrayView((Val**)modifiers, modifierCount));
     return type;
 }
 
@@ -447,15 +491,16 @@ Val* ASTBuilder::getNoDiffModifierVal()
     return getOrCreate<NoDiffModifierVal>();
 }
 
-Type* ASTBuilder::getFuncType(List<Type*> parameters, Type* result)
+FuncType* ASTBuilder::getFuncType(ArrayView<Type*> parameters, Type* result, Type* errorType)
 {
-    auto errorType = getOrCreate<BottomType>();
+    if (!errorType)
+        errorType = getOrCreate<BottomType>();
     return getOrCreate<FuncType>(parameters, result, errorType);
 }
 
-Type* ASTBuilder::getTupleType(List<Type*>& types)
+TupleType* ASTBuilder::getTupleType(List<Type*>& types)
 {
-    return getOrCreate<TupleType>(types);
+    return getOrCreate<TupleType>(types.getArrayView());
 }
 
 TypeType* ASTBuilder::getTypeType(Type* type)
@@ -466,11 +511,11 @@ TypeType* ASTBuilder::getTypeType(Type* type)
 TypeEqualityWitness* ASTBuilder::getTypeEqualityWitness(
     Type* type)
 {
-    return getOrCreate<TypeEqualityWitness>(type);
+    return getOrCreate<TypeEqualityWitness>(type, type);
 }
 
 
-SubtypeWitness* ASTBuilder::getDeclaredSubtypeWitness(
+DeclaredSubtypeWitness* ASTBuilder::getDeclaredSubtypeWitness(
     Type*                   subType,
     Type*                   superType,
     DeclRef<Decl> const&    declRef)
@@ -517,8 +562,8 @@ top:
         // Let's call the intermediate type here `x`, we know that the `b <: c`
         // witness is based on witnesses that `b <: x` and `x <: c`:
         //
-        auto bIsSubtypeOfXWitness = bIsTransitiveSubtypeOfCWitness->subToMid;
-        auto xIsSubtypeOfCWitness = bIsTransitiveSubtypeOfCWitness->midToSup;
+        auto bIsSubtypeOfXWitness = bIsTransitiveSubtypeOfCWitness->getSubToMid();
+        auto xIsSubtypeOfCWitness = bIsTransitiveSubtypeOfCWitness->getMidToSup();
 
         // We can recursively call this operation to produce a witness that
         // `a <: x`, based on the witnesses we already have for `a <: b` and `b <: x`:
@@ -535,8 +580,8 @@ top:
         goto top;
     }
 
-    auto aType = aIsSubtypeOfBWitness->sub;
-    auto cType = bIsSubtypeOfCWitness->sup;
+    auto aType = aIsSubtypeOfBWitness->getSub();
+    auto cType = bIsSubtypeOfCWitness->getSup();
 
     // If the right-hand side is a conjunction witness for `B <: C`
     // of the form `(B <: X)&(B <: Y)`, then we have it that `C = X&Y`
@@ -565,8 +610,8 @@ top:
         // the witness `W` that `B <: X&Y&...` as well as the index
         // `i` of `C` within the conjunction.
         //
-        auto bIsSubtypeOfConjunction = bIsSubtypeViaExtraction->conjunctionWitness;
-        auto indexOfCInConjunction = bIsSubtypeViaExtraction->indexInConjunction;
+        auto bIsSubtypeOfConjunction = bIsSubtypeViaExtraction->getConjunctionWitness();
+        auto indexOfCInConjunction = bIsSubtypeViaExtraction->getIndexInConjunction();
 
         // We lift the extraction to the outside of the composition, by
         // forming a witness for `A <: C` that is of the form
@@ -591,24 +636,14 @@ top:
     // formal set of rules for the allowed structure of our witnesses to
     // guarantee that our simplifications are sufficient.
 
-    TransitiveSubtypeWitness* transitiveWitness = getOrCreateWithDefaultCtor<TransitiveSubtypeWitness>(
+    TransitiveSubtypeWitness* transitiveWitness = getOrCreate<TransitiveSubtypeWitness>(
         aType,
         cType,
         aIsSubtypeOfBWitness,
         bIsSubtypeOfCWitness);
-    transitiveWitness->sub = aType;
-    transitiveWitness->sup = cType;
-    transitiveWitness->subToMid = aIsSubtypeOfBWitness;
-    transitiveWitness->midToSup = bIsSubtypeOfCWitness;
-
     return transitiveWitness;
 }
 
-ThisTypeSubtypeWitness* ASTBuilder::getThisTypeSubtypeWitness(Type* subType, Type* superType)
-{
-    return getOrCreate<ThisTypeSubtypeWitness>(subType, superType);
-}
-
 SubtypeWitness* ASTBuilder::getExtractFromConjunctionSubtypeWitness(
     Type*           subType,
     Type*           superType,
@@ -633,16 +668,11 @@ SubtypeWitness* ASTBuilder::getExtractFromConjunctionSubtypeWitness(
     //
     // * What if the original witness is transitive?
 
-    auto witness = getOrCreateWithDefaultCtor<ExtractFromConjunctionSubtypeWitness>(
+    auto witness = getOrCreate<ExtractFromConjunctionSubtypeWitness>(
         subType,
         superType,
         conjunctionWitness,
         indexOfSuperTypeInConjunction);
-
-    witness->sub = subType;
-    witness->sup = superType;
-    witness->conjunctionWitness = conjunctionWitness;
-    witness->indexInConjunction = indexOfSuperTypeInConjunction;
     return witness;
 }
 
@@ -662,11 +692,11 @@ SubtypeWitness* ASTBuilder::getConjunctionSubtypeWitness(
     auto rExtract = as<ExtractFromConjunctionSubtypeWitness>(subIsRWitness);
     if(lExtract && rExtract)
     {
-        if (lExtract->indexInConjunction == 0
-            && rExtract->indexInConjunction == 1)
+        if (lExtract->getIndexInConjunction() == 0
+            && rExtract->getIndexInConjunction() == 1)
         {
-            auto lInner = lExtract->conjunctionWitness;
-            auto rInner = rExtract->conjunctionWitness;
+            auto lInner = lExtract->getConjunctionWitness();
+            auto rInner = rExtract->getConjunctionWitness();
             if (lInner == rInner)
             {
                 return lInner;
@@ -685,57 +715,30 @@ SubtypeWitness* ASTBuilder::getConjunctionSubtypeWitness(
     // witness) deeper, so that we have more chances to expose a
     // conjunction witness at higher levels.
 
-    auto witness = getOrCreateWithDefaultCtor<ConjunctionSubtypeWitness>(
+    auto witness = getOrCreate<ConjunctionSubtypeWitness>(
         sub,
         lAndR,
         subIsLWitness,
         subIsRWitness);
-    witness->componentWitnesses[0] = subIsLWitness;
-    witness->componentWitnesses[1] = subIsRWitness;
-    witness->sub = sub;
-    witness->sup = lAndR;
     return witness;
 }
 
-bool ASTBuilder::NodeDesc::operator==(NodeDesc const& that) const
+DeclRef<Decl> _getMemberDeclRef(ASTBuilder* builder, DeclRef<Decl> parent, Decl* decl)
 {
-    if (hashCode != that.hashCode) return false;
-    if(type != that.type) return false;
-    if(operands.getCount() != that.operands.getCount()) return false;
-    for(Index i = 0; i < operands.getCount(); ++i)
-    {
-        // Note: we are comparing the operands directly for identity
-        // (pointer equality) rather than doing the `Val`-level
-        // equality check.
-        //
-        // The rationale here is that nodes that will be created
-        // via a `NodeDesc` *should* all be going through the
-        // deduplication path anyway, as should their operands.
-        // 
-        if (operands[i].values.nodeOperand != that.operands[i].values.nodeOperand) return false;
-    }
-    return true;
+    return builder->getMemberDeclRef(parent, decl);
 }
 
-void ASTBuilder::NodeDesc::init()
+
+thread_local ASTBuilder* gCurrentASTBuilder = nullptr;
+
+ASTBuilder* getCurrentASTBuilder()
 {
-    Hasher hasher;
-    hasher.hashValue(Int(type));
-    for(Index i = 0; i < operands.getCount(); ++i)
-    {
-        // Note: we are hashing the raw pointer value rather
-        // than the content of the value node. This is done
-        // to match the semantics implemented for `==` on
-        // `NodeDesc`.
-        //
-        hasher.hashValue(operands[i].values.nodeOperand);
-    }
-    hashCode = hasher.getResult();
+    return gCurrentASTBuilder;
 }
 
-DeclRef<Decl> _getSpecializedDeclRef(ASTBuilder* builder, Decl* decl, Substitutions* subst)
+void setCurrentASTBuilder(ASTBuilder* astBuilder)
 {
-    return builder->getSpecializedDeclRef(decl, subst);
+    gCurrentASTBuilder = astBuilder;
 }
 
 } // namespace Slang
diff --git a/source/slang/slang-ast-builder.h b/source/slang/slang-ast-builder.h
index cf0975cdd..0d63e1060 100644
--- a/source/slang/slang-ast-builder.h
+++ b/source/slang/slang-ast-builder.h
@@ -39,6 +39,11 @@ public:
         /// Get the `IDifferentiable` type
     Type* getDiffInterfaceType();
 
+    Type* getErrorType();
+    Type* getBottomType();
+    Type* getInitializerListType();
+    Type* getOverloadedType();
+
     const ReflectClassInfo* findClassInfo(Name* name);
     SyntaxClass<NodeBase> findSyntaxClass(Name* name);
 
@@ -65,6 +70,8 @@ public:
 
     ~SharedASTBuilder();
 
+    ASTBuilder* getInnerASTBuilder() { return m_astBuilder; }
+
 protected:
     // State shared between ASTBuilders
 
@@ -108,79 +115,59 @@ protected:
 class ASTBuilder : public RefObject
 {
     friend class SharedASTBuilder;
-public:
-    // Node cache:
-    struct NodeOperand
-    {
-        union
-        {
-            NodeBase* nodeOperand;
-            int64_t intOperand;
-        } values;
-        
-        NodeOperand()
-        {
-            values.nodeOperand = nullptr;
-        }
-        
-        NodeOperand(NodeBase* node) { values.nodeOperand = node; }
-        
-        template<typename T>
-        NodeOperand(DeclRef<T> declRef) { values.nodeOperand = declRef.declRefBase; }
-
-        template<typename EnumType>
-        NodeOperand(EnumType intVal)
-        {
-            static_assert(std::is_trivial<EnumType>::value, "Type to construct NodeOperand must be trivial.");
-            static_assert(sizeof(EnumType) <= sizeof(values), "size of operand must be less than pointer size.");
-            values.intOperand = 0;
-            memcpy(&values, &intVal, sizeof(intVal));
-        }
-    };
-    struct NodeDesc
-    {
-        ASTNodeType             type;
-        ShortList<NodeOperand, 4> operands;
-
-        bool operator==(NodeDesc const& that) const;
-        HashCode getHashCode() const { return hashCode; }
-        void init();
-    private:
-        HashCode hashCode = 0;
-    };
 
+public:
     template<typename NodeCreateFunc>
-    NodeBase* _getOrCreateImpl(NodeDesc const& desc, NodeCreateFunc createFunc)
+    NodeBase* _getOrCreateImpl(ValNodeDesc const& desc, NodeCreateFunc createFunc)
     {
         if (auto found = m_cachedNodes.tryGetValue(desc))
             return *found;
 
         auto node = createFunc();
         m_cachedNodes.add(desc, node);
+#ifdef _DEBUG
+        _verifyValDescConsistency(dynamicCast<Val>(node), desc);
+#endif
         return node;
     }
 
     /// A cache for AST nodes that are entirely defined by their node type, with
     /// no need for additional state.
-    Dictionary<NodeDesc, NodeBase*> m_cachedNodes;
+    Dictionary<ValNodeDesc, NodeBase*> m_cachedNodes;
+
+    Dictionary<GenericDecl*, List<Val*>> m_cachedGenericDefaultArgs;
+
+    /// Create AST types
+    template <typename T>
+    T* createImpl()
+    {
+        auto alloced = m_arena.allocate(sizeof(T));
+        memset(alloced, 0, sizeof(T));
+        auto result = _initAndAdd(new (alloced) T);
+        return result;
+    }
 
-    template<int N>
-    static void addOrAppendToNodeList(ShortList<NodeOperand, N>&)
-    {}
+    template<typename T, typename... TArgs>
+    T* createImpl(TArgs&&... args)
+    {
+        auto alloced = m_arena.allocate(sizeof(T));
+        memset(alloced, 0, sizeof(T));
+        auto result = _initAndAdd(new (alloced) T(std::forward<TArgs>(args)...));
+        return result;
+    }
 
-    template<int N, typename T, typename... Ts>
-    static void addOrAppendToNodeList(ShortList<NodeOperand, N>& list, T t, Ts... ts)
+    template <typename T>
+    T* create()
     {
-        list.add(t);
-        addOrAppendToNodeList(list, ts...);
+        static_assert(!IsBaseOf<Val, T>::Value, "ASTBuilder::create cannot be used to create a Val, use getOrCreate instead.");
+        return createImpl<T>();
     }
 
-    template<int N, typename T, typename... Ts>
-    static void addOrAppendToNodeList(ShortList<NodeOperand, N>& list, const List<T>& l, Ts... ts )
+    template<typename T, typename... TArgs>
+    T* create(TArgs&&... args)
     {
-        for(auto t : l)
-            list.add(t);
-        addOrAppendToNodeList(list, ts...);
+        static_assert(!IsBaseOf<Val, T>::Value, "ASTBuilder::create cannot be used to create a Val, use getOrCreate instead.");
+        return createImpl<T>(args...);
     }
 
 public:
@@ -195,37 +182,27 @@ public:
         };
     };
 
-    MemoryArena& getArena() { return m_arena; }
+    Index getEpoch();
 
-        /// Create AST types 
-    template <typename T>
-    T* create()
-    {
-        auto alloced = m_arena.allocate(sizeof(T));
-        memset(alloced, 0, sizeof(T));
-        return _initAndAdd(new (alloced) T);
-    }
+    void incrementEpoch();
 
-    template<typename T, typename... TArgs>
-    T* create(TArgs&&... args)
-    {
-        auto alloced = m_arena.allocate(sizeof(T));
-        memset(alloced, 0, sizeof(T));
-        return _initAndAdd(new (alloced) T(std::forward<TArgs>(args)...));
-    }
+    MemoryArena& getArena() { return m_arena; }
+
+    void _verifyValDescConsistency(Val* val, const ValNodeDesc& expectedDesc);
 
     template<typename T, typename ... TArgs>
     SLANG_FORCE_INLINE T* getOrCreate(TArgs ... args)
     {
         SLANG_COMPILE_TIME_ASSERT(IsValidType<T>::Value);
-        NodeDesc desc;
+        ValNodeDesc desc;
         desc.type = T::kType;
         addOrAppendToNodeList(desc.operands, args...);
         desc.init();
-        return (T*)_getOrCreateImpl(desc, [&]()
+        auto result = (T*)_getOrCreateImpl(desc, [&]()
             {
-                return create<T>(args...);
+                return createImpl<T>(args...);
             });
+        return result;
     }
 
     template<typename T>
@@ -233,63 +210,101 @@ public:
     {
         SLANG_COMPILE_TIME_ASSERT(IsValidType<T>::Value);
 
-        NodeDesc desc;
+        ValNodeDesc desc;
         desc.type = T::kType;
         desc.init();
-        return (T*)_getOrCreateImpl(desc, [this]() { return create<T>(); });
+        auto result = (T*)_getOrCreateImpl(desc, [this]() { return createImpl<T>(); });
+#ifdef _DEBUG
+        _verifyValDescConsistency(dynamicCast<Val>(result), desc);
+#endif
+        return result;
     }
 
-    template<typename T, typename ... TArgs>
-    SLANG_FORCE_INLINE T* getOrCreateWithDefaultCtor(TArgs ... args)
+    InterfaceDecl* createInterfaceDecl(SourceLoc loc)
     {
-        SLANG_COMPILE_TIME_ASSERT(IsValidType<T>::Value);
-        NodeDesc desc;
-        desc.type = T::kType;
-        addOrAppendToNodeList(desc.operands, args...);
-        desc.init();
-        return (T*)_getOrCreateImpl(desc, [&]()
-            {
-                return create<T>();
-            });
+        auto interfaceDecl = create<InterfaceDecl>();
+        // Always include a `This` member and a `This:IThisInterface` member.
+        auto thisDecl = create<ThisTypeDecl>();
+        thisDecl->nameAndLoc.name = m_sharedASTBuilder->getNamePool()->getName(UnownedStringSlice("This", 4));
+        thisDecl->nameAndLoc.loc = loc;
+        interfaceDecl->addMember(thisDecl);
+        auto thisConstraint = create<ThisTypeConstraintDecl>();
+        thisConstraint->loc = loc;
+        thisConstraint->base.type = DeclRefType::create(this, getDirectDeclRef(interfaceDecl));
+        thisDecl->addMember(thisConstraint);
+        return interfaceDecl;
     }
 
     template<typename T>
-    SLANG_FORCE_INLINE T* getOrCreateWithDefaultCtor(ConstArrayView<NodeOperand> operands)
+    DeclRef<T> getDirectDeclRef(T* decl)
     {
-        SLANG_COMPILE_TIME_ASSERT(IsValidType<T>::Value);
-        NodeDesc desc;
-        desc.type = T::kType;
-        desc.operands.addRange(operands);
-        desc.init();
-        return (T*)_getOrCreateImpl(desc, [&]()
-            {
-                return create<T>();
-            });
+        if (!decl)
+            return DeclRef<T>();
+        
+        auto result = DeclRef<T>(getOrCreate<DirectDeclRef>(decl));
+        return result;
     }
 
-    // This is the bottlneck through which all DeclRefs are created.
     template<typename T>
-    DeclRef<T> getSpecializedDeclRef(T* decl, Substitutions* subst)
+    DeclRef<T> getMemberDeclRef(DeclRef<Decl> parent, T* memberDecl)
     {
-        // We never create an actual DeclRefBase node to point to a null decl.
-        if (!decl)
-            return DeclRef<T>();
-
-        // If we don't have substitutions, use the default decl ref if it is created.
-        if (!subst)
+        if (!parent)
+            return getDirectDeclRef(memberDecl);
+        // A Generic value/type ParamDecl is always referred to directly.
+        if (as<GenericTypeParamDecl>(memberDecl) || as<GenericValueParamDecl>(memberDecl))
+            return getDirectDeclRef(memberDecl);
+        if (as<ThisTypeDecl>(memberDecl) && !as<InterfaceDecl>(memberDecl->parentDecl))
+            return as<T>(parent);
+
+        if (auto parentMemberDeclRef = as<MemberDeclRef>(parent.declRefBase))
         {
-            auto defaultDeclRef = static_cast<Decl*>(decl)->defaultDeclRef;
-            if (defaultDeclRef)
-                return defaultDeclRef;
+            return DeclRef<T>(getMemberDeclRef(parentMemberDeclRef->getParent(), memberDecl));
+        }
+        else if (auto lookupDeclRef = as<LookupDeclRef>(parent.declRefBase))
+        {
+            // Handle some specicial case rules due to the way some of our builtin decls are
+            // represented.
+            // - Member(Lookup(w, This), x) ==> Lookup(w, X)
+            //   Lookup of x from This is a lookup from w directly.
+            // - Member(Lookup(w, someExtension), x) ==> Lookup(w, X)
+            //   Lookup of a decl defined in an extension is to lookup directly.
+            // - Member(Lookup(w, AssociatedType), TypeConstraintDecl) ==> Lookup(w, TypeConstraintDecl)
+            //   Type constraint of an associated type is defined directly in w.
+
+            auto parentDeclKind = lookupDeclRef->getDecl()->astNodeType;
+            switch (parentDeclKind)
+            {
+            case ASTNodeType::ThisTypeDecl:
+            case ASTNodeType::ExtensionDecl:
+            case ASTNodeType::AssocTypeDecl:
+                return getLookupDeclRef(lookupDeclRef->getLookupSource(), lookupDeclRef->getWitness(), memberDecl);
+            default:
+                break;
+            }
+        }
+        else if (auto directDeclRef = as<DirectDeclRef>(parent.declRefBase))
+        {
+            return DeclRef<T>(getOrCreate<DirectDeclRef>(memberDecl));
         }
 
-        return getOrCreate<DeclRefBase>(decl, subst);
-    }
+#if _DEBUG
+        // Verify that member is indeed a member of parent.
+        auto parentDecl = parent.getDecl();
+        while (as<ThisTypeDecl>(parentDecl))
+            parentDecl = parentDecl->parentDecl;
+        bool foundParent = false;
+        for (Decl* dd = memberDecl; dd; dd = dd->parentDecl)
+        {
+            if (dd == parentDecl)
+            {
+                foundParent = true;
+                break;
+            }
+        }
+        SLANG_ASSERT(foundParent);
+#endif
 
-    template<typename T>
-    DeclRef<T> getSpecializedDeclRef(T* decl, SubstitutionSet subst)
-    {
-        return getSpecializedDeclRef(decl, subst.substitutions);
+        return DeclRef<T>(getOrCreate<MemberDeclRef>(memberDecl, parent.declRefBase));
     }
 
     ConstantIntVal* getIntVal(Type* type, IntegerLiteralValue value)
@@ -297,61 +312,38 @@ public:
         return getOrCreate<ConstantIntVal>(type, value);
     }
 
-    GenericSubstitution* getOrCreateGenericSubstitution(Substitutions* outer, GenericDecl* decl, ArrayView<Val*> args)
+    DeclRef<Decl> getGenericAppDeclRef(DeclRef<GenericDecl> genericDeclRef, ConstArrayView<Val*> args, Decl* innerDecl = nullptr)
     {
-        NodeDesc desc;
-        desc.type = GenericSubstitution::kType;
-        desc.operands.add(decl);
-        for (auto arg : args)
-            desc.operands.add(arg);
-        if (outer)
-        {
-            desc.operands.add(outer);
-        }
-        desc.init();
-        auto result = (GenericSubstitution*)_getOrCreateImpl(desc, [this]() {return create<GenericSubstitution>(); });
-        if (result->args.getCount() != args.getCount())
-        {
-            SLANG_RELEASE_ASSERT(result->args.getCount() == 0);
-            result->args.addRange(args);
-            result->genericDecl = decl;
-            result->outer = outer;
-        }
-        return result;
-    }
+        if (!innerDecl)
+            innerDecl = genericDeclRef.getDecl()->inner;
 
-    GenericSubstitution* getOrCreateGenericSubstitution(Substitutions* outer, GenericDecl* decl, const List<Val*>& args)
-    {
-        return getOrCreateGenericSubstitution(outer, decl, args.getArrayView());
+        return getOrCreate<GenericAppDeclRef>(innerDecl, genericDeclRef, args);
     }
 
-    template<typename... Args>
-    GenericSubstitution* getOrCreateGenericSubstitution(Substitutions* outer, GenericDecl* decl, Args... args)
+    DeclRef<Decl> getGenericAppDeclRef(DeclRef<GenericDecl> genericDeclRef, Val::OperandView<Val> args, Decl* innerDecl = nullptr)
     {
-        List<Val*> vals;
-        addToList(vals, args...);
-        return getOrCreateGenericSubstitution(outer, decl, vals.getArrayView());
-    }
+        if (!innerDecl)
+            innerDecl = genericDeclRef.getDecl()->inner;
 
+        return getOrCreate<GenericAppDeclRef>(innerDecl, genericDeclRef, args);
+    }
 
-    ThisTypeSubstitution* getOrCreateThisTypeSubstitution(InterfaceDecl* interfaceDecl, SubtypeWitness* subtypeWitness, Substitutions* outer)
+    LookupDeclRef* getLookupDeclRef(Type* base, SubtypeWitness* subtypeWitness, Decl* declToLookup)
     {
-        NodeDesc desc;
-        desc.type = ThisTypeSubstitution::kType;
-        desc.operands.add(interfaceDecl);
-        desc.operands.add(subtypeWitness);
-        if (outer)
-        {
-            desc.operands.add(outer);
-        }
+        ValNodeDesc desc;
+        desc.type = LookupDeclRef::kType;
+        desc.operands.add(ValNodeOperand(subtypeWitness));
+        desc.operands.add(ValNodeOperand(declToLookup));
         desc.init();
-        auto result = (ThisTypeSubstitution*)_getOrCreateImpl(desc, [this]() {return create<ThisTypeSubstitution>(); });
-        result->interfaceDecl = interfaceDecl;
-        result->witness = subtypeWitness;
-        result->outer = outer;
+        auto result = getOrCreate<LookupDeclRef>(declToLookup, base, subtypeWitness);
         return result;
     }
 
+    LookupDeclRef* getLookupDeclRef(SubtypeWitness* subtypeWitness, Decl* declToLookup)
+    {
+        return getLookupDeclRef(subtypeWitness->getSub(), subtypeWitness, declToLookup);
+    }
+
     NodeBase* createByNodeType(ASTNodeType nodeType);
 
         /// Get the built in types
@@ -371,11 +363,12 @@ public:
     SLANG_FORCE_INLINE Type* getBuiltinType(BaseType flavor) { return m_sharedASTBuilder->m_builtinTypes[Index(flavor)]; }
 
     Type* getSpecializedBuiltinType(Type* typeParam, const char* magicTypeName);
+    Type* getSpecializedBuiltinType(ArrayView<Val*> genericArgs, const char* magicTypeName);
 
-    Type* getInitializerListType() { return m_sharedASTBuilder->m_initializerListType; }
-    Type* getOverloadedType() { return m_sharedASTBuilder->m_overloadedType; }
-    Type* getErrorType() { return m_sharedASTBuilder->m_errorType; }
-    Type* getBottomType() { return m_sharedASTBuilder->m_bottomType; }
+    Type* getInitializerListType() { return m_sharedASTBuilder->getInitializerListType(); }
+    Type* getOverloadedType() { return m_sharedASTBuilder->getOverloadedType(); }
+    Type* getErrorType() { return m_sharedASTBuilder->getErrorType(); }
+    Type* getBottomType() { return m_sharedASTBuilder->getBottomType(); }
     Type* getStringType() { return m_sharedASTBuilder->getStringType(); }
     Type* getNullPtrType() { return m_sharedASTBuilder->getNullPtrType(); }
     Type* getNoneType() { return m_sharedASTBuilder->getNoneType(); }
@@ -407,13 +400,18 @@ public:
 
     ConstantBufferType* getConstantBufferType(Type* elementType);
 
+    ParameterBlockType* getParameterBlockType(Type* elementType);
+
+    HLSLStructuredBufferType* getStructuredBufferType(Type* elementType);
+
+    SamplerStateType* getSamplerStateType();
+
     DifferentialPairType* getDifferentialPairType(
         Type* valueType,
         Witness* primalIsDifferentialWitness);
 
     DeclRef<InterfaceDecl> getDifferentiableInterfaceDecl();
     Type* getDifferentiableInterfaceType();
-    Decl* getDifferentiableAssociatedTypeRequirement();
 
     bool isDifferentiableInterfaceAvailable();
 
@@ -423,6 +421,7 @@ public:
         IntVal* maxElementCount);
 
     DeclRef<Decl> getBuiltinDeclRef(const char* builtinMagicTypeName, Val* genericArg);
+    DeclRef<Decl> getBuiltinDeclRef(const char* builtinMagicTypeName, ArrayView<Val*> genericArgs);
 
     Type* getAndType(Type* left, Type* right);
 
@@ -435,9 +434,9 @@ public:
     Val* getSNormModifierVal();
     Val* getNoDiffModifierVal();
 
-    Type* getTupleType(List<Type*>& types);
+    TupleType* getTupleType(List<Type*>& types);
 
-    Type* getFuncType(List<Type*> parameters, Type* result);
+    FuncType* getFuncType(ArrayView<Type*> parameters, Type* result, Type* errorType = nullptr);
 
     TypeType* getTypeType(Type* type);
 
@@ -445,7 +444,7 @@ public:
     TypeEqualityWitness* getTypeEqualityWitness(
         Type* type);
 
-    SubtypeWitness* getDeclaredSubtypeWitness(
+    DeclaredSubtypeWitness* getDeclaredSubtypeWitness(
         Type*                   subType,
         Type*                   superType,
         DeclRef<Decl> const&    declRef);
@@ -455,9 +454,6 @@ public:
         SubtypeWitness*    aIsSubtypeOfBWitness,
         SubtypeWitness*    bIsSubtypeOfCWitness);
 
-        /// Produce a witness that `ThisType(IFoo) <: IFoo`.
-    ThisTypeSubtypeWitness* getThisTypeSubtypeWitness(Type* subType, Type* superType);
-
         /// Produce a witness that `T <: L` or `T <: R` given `T <: L&R`
     SubtypeWitness* getExtractFromConjunctionSubtypeWitness(
         Type*           subType,
@@ -487,14 +483,14 @@ public:
         /// Get the global session
     Session* getGlobalSession() { return m_sharedASTBuilder->m_session; }
 
+    Index getId() { return m_id; }
+
         /// Ctor
     ASTBuilder(SharedASTBuilder* sharedASTBuilder, const String& name);
 
         /// Dtor
     ~ASTBuilder();
 
-    Dictionary<Decl*, GenericSubstitution*> m_genericDefaultSubst;
-
 protected:
     // Special default Ctor that can only be used by SharedASTBuilder
     ASTBuilder();
@@ -512,11 +508,12 @@ protected:
             // Keep such that dtor can be run on ASTBuilder being dtored
             m_dtorNodes.add(node);
         }
-        if (node->getClassInfo().isSubClassOf(*ASTClassInfo::getInfo(Decl::kType)))
+        if (node->getClassInfo().isSubClassOf(*ASTClassInfo::getInfo(Val::kType)))
         {
-            auto decl = (Decl*)(node);
-            decl->defaultDeclRef = getSpecializedDeclRef(decl, nullptr);
+            auto val = (Val*)(node);
+            val->m_resolvedValEpoch = getEpoch();
         }
+
         return node;
     }
 
@@ -529,9 +526,30 @@ protected:
     SharedASTBuilder* m_sharedASTBuilder;
 
     MemoryArena m_arena;
+};
+
+// Retrieves the ASTBuilder for the current compilation session.
+ASTBuilder* getCurrentASTBuilder();
 
+// Sets the ASTBuilder for the current compilation session.
+void setCurrentASTBuilder(ASTBuilder* astBuilder);
+
+struct SetASTBuilderContextRAII
+{
+    ASTBuilder* previousASTBuilder = nullptr;
+    SetASTBuilderContextRAII(ASTBuilder* astBuilder)
+    {
+        previousASTBuilder = getCurrentASTBuilder();
+        setCurrentASTBuilder(astBuilder);
+    }
+    ~SetASTBuilderContextRAII()
+    {
+        setCurrentASTBuilder(previousASTBuilder);
+    }
 };
 
+#define SLANG_AST_BUILDER_RAII(astBuilder) SetASTBuilderContextRAII _setASTBuilderContextRAII(astBuilder)
+
 } // namespace Slang
 
 #endif
diff --git a/source/slang/slang-ast-decl-ref.cpp b/source/slang/slang-ast-decl-ref.cpp
new file mode 100644
index 000000000..4384a6df9
--- /dev/null
+++ b/source/slang/slang-ast-decl-ref.cpp
@@ -0,0 +1,461 @@
+#include "slang-ast-builder.h"
+#include "slang-ast-reflect.h"
+#include "slang-generated-ast.h"
+#include "slang-generated-ast-macro.h"
+#include "slang-check-impl.h"
+
+namespace Slang
+{
+
+DeclRefBase* DirectDeclRef::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
+{
+    SLANG_UNUSED(astBuilder);
+    SLANG_UNUSED(subst);
+    SLANG_UNUSED(ioDiff);
+    return this;
+}
+
+void DirectDeclRef::_toTextOverride(StringBuilder& out)
+{
+    if (getDecl()->getName() && getDecl()->getName()->text.getLength() != 0)
+    {
+        out << getDecl()->getName()->text;
+    }
+}
+
+Val* DirectDeclRef::_resolveImplOverride()
+{
+    return this;
+}
+
+DeclRefBase* DirectDeclRef::_getBaseOverride()
+{
+    return nullptr;
+}
+
+DeclRefBase* _getDeclRefFromVal(Val* val)
+{
+    if (auto declRefType = as<DeclRefType>(val))
+        return declRefType->getDeclRef();
+    else if (auto genParamIntVal = as<GenericParamIntVal>(val))
+        return genParamIntVal->getDeclRef();
+    else if (auto declaredSubtypeWitness = as<DeclaredSubtypeWitness>(val))
+        return declaredSubtypeWitness->getDeclRef();
+    else if (auto declRef = as<DeclRefBase>(val))
+        return declRef;
+    return nullptr;
+}
+
+DeclRefBase* _resolveAsDeclRef(DeclRefBase* declRefToResolve)
+{
+    if (auto rs = _getDeclRefFromVal(declRefToResolve->resolve()))
+        return rs;
+    return declRefToResolve;
+}
+
+DeclRefBase* MemberDeclRef::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
+{
+    int diff = 0;
+    auto substParent = getParentOperand()->substituteImpl(astBuilder, subst, &diff);
+    if (diff)
+    {
+        (*ioDiff)++;
+        return astBuilder->getMemberDeclRef(substParent, getDecl());
+    }
+    return this;
+}
+
+void MemberDeclRef::_toTextOverride(StringBuilder& out)
+{
+    getParentOperand()->toText(out);
+    if (out.getLength() && !out.endsWith("."))
+        out << ".";
+    if (getDecl()->getName() && getDecl()->getName()->text.getLength() != 0)
+    {
+        out << getDecl()->getName()->text;
+    }
+}
+
+Val* MemberDeclRef::_resolveImplOverride()
+{
+    auto resolvedParent = _resolveAsDeclRef(getParentOperand());
+    if (resolvedParent != getParentOperand())
+    {
+        return getCurrentASTBuilder()->getMemberDeclRef(resolvedParent, getDecl());
+    }
+    return this;
+}
+
+DeclRefBase* MemberDeclRef::_getBaseOverride()
+{
+    return getParentOperand();
+}
+
+Decl* LookupDeclRef::getSupDecl()
+{
+    if (auto supType = as<DeclRefType>(getWitness()->getSup()))
+    {
+        return supType->getDeclRef().getDecl();
+    }
+    // If we reach here, something is wrong.
+    SLANG_UNEXPECTED("Invalid lookup declref");
+}
+
+DeclRefBase* LookupDeclRef::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
+{
+    int diff = 0;
+ 
+    auto substWitness = as<SubtypeWitness>(getWitness()->substituteImpl(astBuilder, subst, &diff));
+    if (diff == 0)
+        return this;
+    (*ioDiff)++;
+    
+    auto substSource = as<Type>(getLookupSource()->substituteImpl(astBuilder, subst, &diff));
+    SLANG_ASSERT(substSource);
+
+    if (auto resolved = _getDeclRefFromVal(tryResolve(substWitness, substSource)))
+        return resolved;
+
+    return astBuilder->getLookupDeclRef(substSource, substWitness, getDecl());
+}
+
+void LookupDeclRef::_toTextOverride(StringBuilder& out)
+{
+    getLookupSource()->toText(out);
+    if (out.getLength() && !out.endsWith("."))
+        out << ".";
+    if (getDecl()->getName() && getDecl()->getName()->text.getLength() != 0)
+    {
+        out << getDecl()->getName()->text;
+    }
+}
+
+Val* LookupDeclRef::_resolveImplOverride()
+{
+    auto astBuilder = getCurrentASTBuilder();
+    Val* resolved = this;
+
+    auto newLookupSource = as<Type>(getLookupSource()->resolve());
+    SLANG_ASSERT(newLookupSource);
+
+    auto newWitness = as<SubtypeWitness>(getWitness()->resolve());
+    SLANG_ASSERT(newWitness);
+
+    if (auto resolvedVal = tryResolve(newWitness, newLookupSource))
+        return resolvedVal;
+    if (newLookupSource != getLookupSource() || newWitness != getWitness())
+        resolved = astBuilder->getLookupDeclRef(newLookupSource, newWitness, getDecl());
+    return resolved;
+}
+
+DeclRefBase* LookupDeclRef::_getBaseOverride()
+{
+    return nullptr;
+}
+
+Val* LookupDeclRef::tryResolve(SubtypeWitness* newWitness, Type* newLookupSource)
+{
+    auto astBuilder = getCurrentASTBuilder();
+    Decl* requirementKey = getDecl();
+    RequirementWitness requirementWitness = tryLookUpRequirementWitness(astBuilder, newWitness, requirementKey);
+    switch (requirementWitness.getFlavor())
+    {
+    default:
+        // No usable value was found, so there is nothing we can do.
+        break;
+
+    case RequirementWitness::Flavor::val:
+    {
+        auto satisfyingVal = requirementWitness.getVal();
+        return satisfyingVal;
+    }
+    break;
+    }
+
+    // Hard code implementation of T.Differential.Differential == T.Differential rule.
+    auto builtinReq = requirementKey->findModifier<BuiltinRequirementModifier>();
+    bool isConstraint = false;
+    if (!builtinReq)
+    {
+        if (auto parentAssocType = as<AssocTypeDecl>(requirementKey->parentDecl))
+        {
+            builtinReq = parentAssocType->findModifier<BuiltinRequirementModifier>();
+            isConstraint = true;
+        }
+        if (!builtinReq)
+            return nullptr;
+    }
+    if (builtinReq->kind != BuiltinRequirementKind::DifferentialType)
+        return nullptr;
+    // Is the concrete type a Differential associated type?
+    auto innerDeclRefType = as<DeclRefType>(newLookupSource);
+    if (!innerDeclRefType)
+        return nullptr;
+    auto innerBuiltinReq = innerDeclRefType->getDeclRef().getDecl()->findModifier<BuiltinRequirementModifier>();
+    if (!innerBuiltinReq)
+        return nullptr;
+    if (innerBuiltinReq->kind != BuiltinRequirementKind::DifferentialType)
+        return nullptr;
+    if (isConstraint)
+        return newWitness;
+    if (innerDeclRefType->getDeclRef() != this)
+    {
+        auto result = innerDeclRefType->getDeclRef().declRefBase->resolve();
+        if (result)
+            return result;
+    }
+    return innerDeclRefType;
+}
+
+DeclRefBase* GenericAppDeclRef::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
+{
+    int diff = 0;
+    auto substGenericDeclRef = getGenericDeclRef()->substituteImpl(astBuilder, subst, &diff);
+    List<Val*> substArgs;
+    for (auto arg : getArgs())
+    {
+        substArgs.add(arg->substituteImpl(astBuilder, subst, &diff));
+    }
+    if (diff == 0)
+        return this;
+    (*ioDiff)++;
+    return astBuilder->getGenericAppDeclRef(substGenericDeclRef, substArgs.getArrayView(), getDecl());
+}
+
+GenericDecl* GenericAppDeclRef::getGenericDecl() { return as<GenericDecl>(getGenericDeclRef()->getDecl()); }
+
+
+void GenericAppDeclRef::_toTextOverride(StringBuilder& out)
+{
+    auto genericDecl = as<GenericDecl>(getGenericDeclRef()->getDecl());
+    Index paramCount = 0;
+    for (auto member : genericDecl->members)
+        if (as<GenericTypeParamDecl>(member) || as<GenericValueParamDecl>(member))
+            paramCount++;
+    getGenericDeclRef()->toText(out);
+    out << "<";
+    auto args = getArgs();
+    Index argCount = args.getCount();
+    for (Index aa = 0; aa < Math::Min(paramCount, argCount); ++aa)
+    {
+        if (aa != 0) out << ", ";
+        args[aa]->toText(out);
+    }
+    out << ">";
+}
+
+Val* GenericAppDeclRef::_resolveImplOverride()
+{
+    auto astBuilder = getCurrentASTBuilder();
+    Val* resolvedVal = this;
+    auto resolvedGenericDeclRef = _resolveAsDeclRef(getGenericDeclRef());
+    bool diff = false;
+    if (resolvedGenericDeclRef != getGenericDeclRef())
+        diff = true;
+    List<Val*> resolvedArgs;
+    for (auto arg : getArgs())
+    {
+        auto resolvedArg = arg->resolve();
+        resolvedArgs.add(resolvedArg);
+        if (resolvedArg != arg)
+            diff = true;
+    }
+    if (diff)
+        resolvedVal = astBuilder->getGenericAppDeclRef(resolvedGenericDeclRef, resolvedArgs.getArrayView(), getDecl());
+    return resolvedVal;
+}
+
+DeclRefBase* GenericAppDeclRef::_getBaseOverride()
+{
+    return getGenericDeclRef();
+}
+
+// Convenience accessors for common properties of declarations
+
+DeclRefBase* DeclRefBase::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
+{
+    SLANG_AST_NODE_VIRTUAL_CALL(DeclRefBase, substituteImpl, (astBuilder, subst, ioDiff));
+}
+
+DeclRefBase* DeclRefBase::getBase() { SLANG_AST_NODE_VIRTUAL_CALL(DeclRefBase, getBase, ()); }
+void DeclRefBase::toText(StringBuilder& out) { SLANG_AST_NODE_VIRTUAL_CALL(DeclRefBase, toText, (out)); }
+
+Name* DeclRefBase::getName() const
+{
+    return getDecl()->nameAndLoc.name;
+}
+
+SourceLoc DeclRefBase::getNameLoc() const
+{
+    return getDecl()->nameAndLoc.loc;
+}
+
+SourceLoc DeclRefBase::getLoc() const
+{
+    return getDecl()->loc;
+}
+
+DeclRefBase* DeclRefBase::getParent()
+{
+    auto astBuilder = getCurrentASTBuilder();
+    if (!getDecl()->parentDecl)
+        return nullptr;
+    auto parentDecl = getDecl()->parentDecl;
+    for (auto base = getBase(); base; base = base->getBase())
+    {
+        if (base->getDecl() == parentDecl)
+            return base;
+        bool parentIsChildOfBase = false;
+        for (auto dd = parentDecl->parentDecl; dd; dd = dd->parentDecl)
+        {
+            if (dd == base->getDecl())
+            {
+                parentIsChildOfBase = true;
+                break;
+            }
+        }
+        if (parentIsChildOfBase)
+            return astBuilder->getMemberDeclRef(base, parentDecl);
+    }
+    return astBuilder->getDirectDeclRef(parentDecl);
+}
+
+SubstitutionSet::operator bool() const
+{
+    return declRef != nullptr && !as<DirectDeclRef>(declRef);
+}
+
+Val::OperandView<Val> tryGetGenericArguments(SubstitutionSet substSet, Decl* genericDecl)
+{
+    if (!substSet.declRef)
+        return Val::OperandView<Val>();
+
+    DeclRefBase* currentDeclRef = substSet.declRef;
+    // search for a substitution that might apply to us
+    for (auto s = currentDeclRef; s; s = s->getBase())
+    {
+        auto genericAppDeclRef = as<GenericAppDeclRef>(s);
+        if (!genericAppDeclRef)
+            continue;
+
+        // the generic decl associated with the substitution list must be
+        // the generic decl that declared this parameter
+        auto parentGeneric = genericAppDeclRef->getGenericDecl();
+        if (parentGeneric != genericDecl)
+            continue;
+
+        return genericAppDeclRef->getArgs();
+    }
+    return Val::OperandView<Val>();
+}
+
+Type* SubstitutionSet::applyToType(ASTBuilder* astBuilder, Type* type) const
+{
+    if (!type)
+        return nullptr;
+    int diff = 0;
+    auto newType = as<Type>(type->substituteImpl(astBuilder, *this, &diff));
+    if (diff && newType)
+        return newType;
+    return type;
+}
+
+SubstExpr<Expr> applySubstitutionToExpr(SubstitutionSet substSet, Expr* expr)
+{
+    return SubstExpr<Expr>(expr, substSet);
+}
+
+
+DeclRefBase* SubstitutionSet::applyToDeclRef(ASTBuilder* astBuilder, DeclRefBase* otherDeclRef) const
+{
+    int diff = 0;
+    return otherDeclRef->substituteImpl(astBuilder, *this, &diff);
+}
+
+LookupDeclRef* SubstitutionSet::findLookupDeclRef() const
+{
+    for (auto s = declRef; s; s = s->getBase())
+    {
+        if (auto lookupDeclRef = as<LookupDeclRef>(s))
+            return lookupDeclRef;
+    }
+    return nullptr;
+}
+
+DeclRefBase* SubstitutionSet::getInnerMostNodeWithSubstInfo() const
+{
+    for (auto s = declRef; s; s = s->getBase())
+    {
+        if (as<LookupDeclRef>(s) || as<GenericAppDeclRef>(s))
+            return s;
+    }
+    return nullptr;
+}
+
+
+GenericAppDeclRef* SubstitutionSet::findGenericAppDeclRef(GenericDecl* genericDecl) const
+{
+    for (auto s = declRef; s; s = s->getBase())
+    {
+        if (auto genApp = as<GenericAppDeclRef>(s))
+        {
+            if (genApp->getGenericDecl() == genericDecl)
+                return genApp;
+        }
+    }
+    return nullptr;
+}
+
+GenericAppDeclRef* SubstitutionSet::findGenericAppDeclRef() const
+{
+    for (auto s = declRef; s; s = s->getBase())
+    {
+        if (auto genApp = as<GenericAppDeclRef>(s))
+        {
+            return genApp;
+        }
+    }
+    return nullptr;
+}
+
+DeclRef<Decl> createDefaultSubstitutionsIfNeeded(
+    ASTBuilder* astBuilder,
+    SemanticsVisitor* semantics,
+    DeclRef<Decl>   declRef)
+{
+    if (declRef.as<GenericTypeParamDecl>())
+        return declRef;
+    if (declRef.as<GenericValueParamDecl>())
+        return declRef;
+    if (declRef.as<GenericTypeConstraintDecl>())
+        return declRef;
+    ShortList<GenericDecl*> genericParentDecls;
+    auto lastSubstNode = SubstitutionSet(declRef).getInnerMostNodeWithSubstInfo();
+    auto lastGenApp = as<GenericAppDeclRef>(lastSubstNode);
+    for (auto dd = declRef.getDecl()->parentDecl; dd; dd = dd->parentDecl)
+    {
+        if (lastGenApp && dd == lastGenApp->getGenericDecl())
+            break;
+        if (auto gen = as<GenericDecl>(dd))
+            genericParentDecls.add(gen);
+    }
+    DeclRef<Decl> parentDeclRef = lastSubstNode;
+    for (auto i = genericParentDecls.getCount() - 1; i >= 0; i--)
+    {
+        auto current = genericParentDecls[i];
+        auto args = getDefaultSubstitutionArgs(astBuilder, semantics, current);
+        if (parentDeclRef)
+        {
+            parentDeclRef = astBuilder->getMemberDeclRef(parentDeclRef, current);
+        }
+        else
+        {
+            parentDeclRef = astBuilder->getDirectDeclRef(current);
+        }
+        parentDeclRef = astBuilder->getGenericAppDeclRef(parentDeclRef.as<GenericDecl>(), args.getArrayView());
+    }
+    if (parentDeclRef.getDecl() == declRef.getDecl())
+        return parentDeclRef;
+    return astBuilder->getMemberDeclRef(parentDeclRef, declRef.getDecl());
+}
+}
diff --git a/source/slang/slang-ast-decl.cpp b/source/slang/slang-ast-decl.cpp
index 2f1c7c47e..9dbd006a0 100644
--- a/source/slang/slang-ast-decl.cpp
+++ b/source/slang/slang-ast-decl.cpp
@@ -4,6 +4,7 @@
 #include <assert.h>
 
 #include "slang-generated-ast-macro.h"
+#include "slang-ast-decl.h"
 
 namespace Slang {
 
@@ -118,4 +119,21 @@ bool isLocalVar(const Decl* decl)
     return false;
 }
 
+ThisTypeDecl* InterfaceDecl::getThisTypeDecl()
+{
+    for (auto member : members)
+    {
+        if (auto thisTypeDeclCandidate = as<ThisTypeDecl>(member))
+        {
+            return thisTypeDeclCandidate;
+        }
+    }
+    SLANG_UNREACHABLE("InterfaceDecl does not have a ThisType decl.");
+}
+
+InterfaceDecl* ThisTypeConstraintDecl::getInterfaceDecl()
+{
+    return as<InterfaceDecl>(parentDecl->parentDecl);
+}
+
 } // namespace Slang
diff --git a/source/slang/slang-ast-decl.h b/source/slang/slang-ast-decl.h
index 61e623366..8266d77c7 100644
--- a/source/slang/slang-ast-decl.h
+++ b/source/slang/slang-ast-decl.h
@@ -56,6 +56,15 @@ class ContainerDecl: public Decl
         return transparentMembers;
     }
 
+    void addMember(Decl* member)
+    {
+        if (member)
+        {
+            member->parentDecl = this;
+            members.add(member);
+        }
+    }
+
     SLANG_UNREFLECTED   // We don't want to reflect the following fields
 
 private:
@@ -178,12 +187,19 @@ class EnumCaseDecl : public Decl
     Expr* tagExpr = nullptr;
 };
 
+// A member of InterfaceDecl representing the abstract ThisType.
+class ThisTypeDecl : public AggTypeDecl
+{
+    SLANG_AST_CLASS(ThisTypeDecl)
+};
+
 // An interface which other types can conform to
 class InterfaceDecl : public  AggTypeDecl
 {
     SLANG_AST_CLASS(InterfaceDecl)
-};
 
+    ThisTypeDecl* getThisTypeDecl();
+};
 
 class TypeConstraintDecl : public  Decl
 {
@@ -195,6 +211,15 @@ class TypeConstraintDecl : public  Decl
     const TypeExp& _getSupOverride() const;
 };
 
+class ThisTypeConstraintDecl : public TypeConstraintDecl
+{
+    SLANG_AST_CLASS(ThisTypeConstraintDecl)
+
+    TypeExp base;
+    const TypeExp& _getSupOverride() const { return base; }
+    InterfaceDecl* getInterfaceDecl();
+};
+
 // A kind of pseudo-member that represents an explicit
 // or implicit inheritance relationship.
 //
diff --git a/source/slang/slang-ast-dump.cpp b/source/slang/slang-ast-dump.cpp
index 0ab440a18..65718833b 100644
--- a/source/slang/slang-ast-dump.cpp
+++ b/source/slang/slang-ast-dump.cpp
@@ -65,18 +65,6 @@ struct ASTDumpContext
         }
     }
 
-    void dump(Substitutions* subs)
-    {
-        if (subs == nullptr)
-        {
-            _dumpPtr(nullptr);
-        }
-        else
-        {
-            dumpObject(subs->getClassInfo(), subs);
-        }
-    }
-
     void dump(const Name* name)
     {
         if (name == nullptr)
@@ -608,6 +596,40 @@ struct ASTDumpContext
         m_writer->emit("\n");
     }
 
+    template<int N>
+    void dump(const ShortList<ValNodeOperand, N>& operands)
+    {
+        m_writer->emit("(");
+        bool isFirst = true;
+        for (auto operand : operands)
+        {
+            if (!isFirst)
+            {
+                m_writer->emit(", ");
+            }
+            isFirst = false;
+            dumpField("operand", operand);
+        }
+
+        m_writer->emit(")");
+    }
+
+    void dump(ValNodeOperand operand)
+    {
+        switch (operand.kind)
+        {
+        case ValNodeOperandKind::ConstantValue:
+            dump(operand.values.intOperand);
+            break;
+        case ValNodeOperandKind::ValNode:
+            dump(operand.values.nodeOperand);
+            break;
+        case ValNodeOperandKind::ASTNode:
+            dump(operand.values.nodeOperand);
+            break;
+        }
+    }
+
     void dump(ASTNodeType nodeType)
     {
         // Get the class
@@ -616,6 +638,15 @@ struct ASTDumpContext
         m_writer->emit(info->m_name);
     }
 
+    void dump(KeyValuePair<DeclRefBase*, SubtypeWitness*> pair)
+    {
+        m_writer->emit("(");
+        dump(pair.key);
+        m_writer->emit(", ");
+        dump(pair.value);
+        m_writer->emit(")");
+    }
+
     void dumpObjectFull(NodeBase* node);
 
     ASTDumpContext(SourceWriter* writer, ASTDumpUtil::Flags flags, ASTDumpUtil::Style dumpStyle):
diff --git a/source/slang/slang-ast-expr.h b/source/slang/slang-ast-expr.h
index 07bf2f033..28ce2e4d1 100644
--- a/source/slang/slang-ast-expr.h
+++ b/source/slang/slang-ast-expr.h
@@ -560,17 +560,6 @@ class TreatAsDifferentiableExpr : public Expr
     Flavor flavor;
 };
 
-    /// A type expression of the form `__TaggedUnion(A, ...)`.
-    ///
-    /// An expression of this form will resolve to a `TaggedUnionType`
-    /// when checked.
-    ///
-class TaggedUnionTypeExpr: public Expr
-{
-    SLANG_AST_CLASS(TaggedUnionTypeExpr)
-    List<TypeExp> caseTypes;
-};
-
     /// A type expression of the form `This`
     ///
     /// Refers to the type of `this` in the current context.
@@ -639,7 +628,7 @@ public:
     DeclRef<GenericDecl> baseGenericDeclRef;
 
         /// A substitution that includes the generic arguments known so far
-    GenericSubstitution* substWithKnownGenericArgs = nullptr;
+    List<Val*> knownGenericArgs;
 };
 
 } // namespace Slang
diff --git a/source/slang/slang-ast-iterator.h b/source/slang/slang-ast-iterator.h
index ea3db6937..fb3d50b4f 100644
--- a/source/slang/slang-ast-iterator.h
+++ b/source/slang/slang-ast-iterator.h
@@ -99,11 +99,6 @@ struct ASTIterator
             dispatchIfNotNull(expr->base.exp);
         }
 
-        void visitTaggedUnionTypeExpr(TaggedUnionTypeExpr* expr)
-        {
-            iterator->maybeDispatchCallback(expr);
-        }
-
         void visitInvokeExpr(InvokeExpr* expr)
         {
             iterator->maybeDispatchCallback(expr);
diff --git a/source/slang/slang-ast-modifier.cpp b/source/slang/slang-ast-modifier.cpp
index 3daa9b056..84046a601 100644
--- a/source/slang/slang-ast-modifier.cpp
+++ b/source/slang/slang-ast-modifier.cpp
@@ -4,5 +4,10 @@
 
 namespace Slang
 {
-
+const OrderedDictionary<DeclRefBase*, SubtypeWitness*>& DifferentiableAttribute::getMapTypeToIDifferentiableWitness()
+{
+    for (Index i = m_mapToIDifferentiableWitness.getCount(); i < m_typeToIDifferentiableWitnessMappings.getCount(); i++)
+        m_mapToIDifferentiableWitness.add(m_typeToIDifferentiableWitnessMappings[i].key, m_typeToIDifferentiableWitnessMappings[i].value);
+    return m_mapToIDifferentiableWitness;
+}
 } // namespace Slang
diff --git a/source/slang/slang-ast-modifier.h b/source/slang/slang-ast-modifier.h
index fd317a2c2..8e7cc9193 100644
--- a/source/slang/slang-ast-modifier.h
+++ b/source/slang/slang-ast-modifier.h
@@ -600,7 +600,7 @@ class Attribute : public AttributeBase
 {
     SLANG_AST_CLASS(Attribute)
  
-    AttributeArgumentValueDict intArgVals;
+    List<Val*> intArgVals;
 };
 
 class UserDefinedAttribute : public Attribute 
@@ -1054,10 +1054,23 @@ class DifferentiableAttribute : public Attribute
 {
     SLANG_AST_CLASS(DifferentiableAttribute)
 
+    List<KeyValuePair<DeclRefBase*, SubtypeWitness*>> m_typeToIDifferentiableWitnessMappings;
+
+    void addType(DeclRefBase* declRef, SubtypeWitness* witness)
+    {
+        getMapTypeToIDifferentiableWitness();
+        if (m_mapToIDifferentiableWitness.addIfNotExists(declRef, witness))
+        {
+            m_typeToIDifferentiableWitnessMappings.add(KeyValuePair<DeclRefBase*, SubtypeWitness*>(declRef, witness));
+        }
+    }
+
     /// Mapping from types to subtype witnesses for conformance to IDifferentiable.
-    OrderedDictionary<DeclRefBase*, SubtypeWitness*>   m_mapTypeToIDifferentiableWitness;
+    const OrderedDictionary<DeclRefBase*, SubtypeWitness*>& getMapTypeToIDifferentiableWitness();
 
     SLANG_UNREFLECTED ValSet m_typeRegistrationWorkingSet;
+private:
+    OrderedDictionary<DeclRefBase*, SubtypeWitness*> m_mapToIDifferentiableWitness;
 };
 
 class DllImportAttribute : public Attribute
diff --git a/source/slang/slang-ast-natural-layout.cpp b/source/slang/slang-ast-natural-layout.cpp
index 1789c5cea..4a4ef37fb 100644
--- a/source/slang/slang-ast-natural-layout.cpp
+++ b/source/slang/slang-ast-natural-layout.cpp
@@ -70,9 +70,9 @@ Count ASTNaturalLayoutContext::_getCount(IntVal* intVal)
 {
     if (auto constIntVal = as<ConstantIntVal>(intVal))
     {
-        if (constIntVal->value >= 0)
+        if (constIntVal->getValue() >= 0)
         {
-            return Count(constIntVal->value);
+            return Count(constIntVal->getValue());
         }
     }
 
@@ -115,9 +115,9 @@ NaturalSize ASTNaturalLayoutContext::_calcSizeImpl(Type* type)
 {
     if (VectorExpressionType* vecType = as<VectorExpressionType>(type))
     {
-        const Count elementCount = _getCount(vecType->elementCount);
+        const Count elementCount = _getCount(vecType->getElementCount());
         return (elementCount > 0) ? 
-            calcSize(vecType->elementType) * elementCount : 
+            calcSize(vecType->getElementType()) * elementCount : 
             NaturalSize::makeInvalid();
     }
     else if (auto matType = as<MatrixExpressionType>(type))
@@ -130,7 +130,7 @@ NaturalSize ASTNaturalLayoutContext::_calcSizeImpl(Type* type)
     }
     else if (auto basicType = as<BasicExpressionType>(type))
     {
-        return NaturalSize::makeFromBaseType(basicType->baseType);
+        return NaturalSize::makeFromBaseType(basicType->getBaseType());
     }
     else if (as<PtrTypeBase>(type) || as<NullPtrType>(type))
     {
@@ -146,7 +146,7 @@ NaturalSize ASTNaturalLayoutContext::_calcSizeImpl(Type* type)
     }
     else if (auto namedType = as<NamedExpressionType>(type))
     {
-        return calcSize(namedType->innerType);
+        return calcSize(namedType->getCanonicalType());
     }
     else if (const auto tupleType = as<TupleType>(type))
     {
@@ -154,9 +154,9 @@ NaturalSize ASTNaturalLayoutContext::_calcSizeImpl(Type* type)
         NaturalSize size = NaturalSize::makeEmpty();
 
         // Accumulate over all the member types
-        for (auto cur : tupleType->memberTypes)
+        for (auto cur = 0; cur < tupleType->getMemberCount(); cur++)
         {
-            const auto curSize = calcSize(cur);
+            const auto curSize = calcSize(tupleType->getMember(cur));
             if (!curSize)
             {
                 return NaturalSize::makeInvalid();
@@ -166,36 +166,14 @@ NaturalSize ASTNaturalLayoutContext::_calcSizeImpl(Type* type)
 
         return size;
     }
-    else if (const auto taggedUnion = as<TaggedUnionType>(type))
-    {
-        NaturalSize size = NaturalSize::makeInvalid();
-
-        for( auto caseType : taggedUnion->caseTypes )
-        {
-            const NaturalSize caseSize = calcSize(caseType);
-            if (!caseSize)
-            {
-                return NaturalSize::makeInvalid();
-            }
-            size = NaturalSize::calcUnion(size, caseSize);
-        }
-
-        // After we've computed the size required to hold all the
-        // case types, we will allocate space for the tag field.
-        
-        // Currently we assume uint32_t on all targets
-        size.append(NaturalSize::makeFromBaseType(BaseType::UInt));
-
-        return size;
-    }
     else if( auto declRefType = as<DeclRefType>(type) )
     {
-        if (const auto enumDeclRef = declRefType->declRef.as<EnumDecl>())
+        if (const auto enumDeclRef = declRefType->getDeclRef().as<EnumDecl>())
         {
             Type* tagType = getTagType(m_astBuilder, enumDeclRef);
             return calcSize(tagType);
         }
-        else if(const auto structDeclRef = declRefType->declRef.as<StructDecl>())
+        else if(const auto structDeclRef = declRefType->getDeclRef().as<StructDecl>())
         {
             // Poison the cache whilst we construct
             m_typeToSize.add(type, NaturalSize::makeInvalid());
@@ -208,7 +186,7 @@ NaturalSize ASTNaturalLayoutContext::_calcSizeImpl(Type* type)
                 // Look for a struct type that it inherits from
                 if (auto inheritedDeclRef = as<DeclRefType>(inherited->base.type))
                 {
-                    if (auto parentDecl = inheritedDeclRef->declRef.as<StructDecl>())
+                    if (auto parentDecl = inheritedDeclRef->getDeclRef().as<StructDecl>())
                     {
                         // We can only inherit from one thing
                         size = calcSize(inherited->base.type);
@@ -237,7 +215,7 @@ NaturalSize ASTNaturalLayoutContext::_calcSizeImpl(Type* type)
 
             return size; 
         }
-        else if (const auto typeDef = declRefType->declRef.as<TypeDefDecl>())
+        else if (const auto typeDef = declRefType->getDeclRef().as<TypeDefDecl>())
         {
             return calcSize(typeDef.getDecl()->type);
         }
diff --git a/source/slang/slang-ast-print.cpp b/source/slang/slang-ast-print.cpp
index 84c521108..b80afeee1 100644
--- a/source/slang/slang-ast-print.cpp
+++ b/source/slang/slang-ast-print.cpp
@@ -36,12 +36,12 @@ void ASTPrinter::addType(Type* type)
     {
         if (auto vectorType = as<VectorExpressionType>(type))
         {
-            if (as<BasicExpressionType>(vectorType->elementType))
+            if (as<BasicExpressionType>(vectorType->getElementType()))
             {
-                vectorType->elementType->toText(m_builder);
-                if (as<ConstantIntVal>(vectorType->elementCount))
+                vectorType->getElementType()->toText(m_builder);
+                if (as<ConstantIntVal>(vectorType->getElementCount()))
                 {
-                    m_builder << vectorType->elementCount;
+                    m_builder << vectorType->getElementCount();
                     return;
                 }
             }
@@ -107,14 +107,14 @@ void ASTPrinter::_addDeclPathRec(const DeclRef<Decl>& declRef, Index depth)
     auto& sb = m_builder;
 
     // Find the parent declaration
-    auto parentDeclRef = declRef.getParent(m_astBuilder);
+    auto parentDeclRef = declRef.getParent();
 
     // If the immediate parent is a generic, then we probably
     // want the declaration above that...
     auto parentGenericDeclRef = parentDeclRef.as<GenericDecl>();
     if (parentGenericDeclRef)
     {
-        parentDeclRef = parentGenericDeclRef.getParent(m_astBuilder);
+        parentDeclRef = parentGenericDeclRef.getParent();
     }
 
     // Depending on what the parent is, we may want to format things specially
@@ -172,12 +172,9 @@ void ASTPrinter::_addDeclPathRec(const DeclRef<Decl>& declRef, Index depth)
         !declRef.as<GenericValueParamDecl>() &&
         !declRef.as<GenericTypeParamDecl>())
     {
-        auto genSubst = as<GenericSubstitution>(declRef.getSubst());
-        if (genSubst)
+        auto substArgs = tryGetGenericArguments(SubstitutionSet(declRef), parentGenericDeclRef.getDecl());
+        if (substArgs.getCount())
         {
-            SLANG_RELEASE_ASSERT(genSubst);
-            SLANG_RELEASE_ASSERT(genSubst->getGenericDecl() == parentGenericDeclRef.getDecl());
-
             // If the name we printed previously was an operator
             // that ends with `<`, then immediately printing the
             // generic arguments inside `<...>` may cause it to
@@ -193,7 +190,7 @@ void ASTPrinter::_addDeclPathRec(const DeclRef<Decl>& declRef, Index depth)
 
             sb << "<";
             bool first = true;
-            for (auto arg : genSubst->getArgs())
+            for (auto arg : substArgs)
             {
                 // When printing the representation of a specialized
                 // generic declaration we don't want to include the
@@ -331,7 +328,7 @@ void ASTPrinter::addDeclParams(const DeclRef<Decl>& declRef, List<Range<Index>>*
     {
         addGenericParams(genericDeclRef);
 
-        addDeclParams(m_astBuilder->getSpecializedDeclRef<Decl>(getInner(genericDeclRef), genericDeclRef.getSubst()), outParamRange);
+        addDeclParams(m_astBuilder->getMemberDeclRef(genericDeclRef, genericDeclRef.getDecl()->inner), outParamRange);
     }
     else
     {
@@ -443,7 +440,7 @@ void ASTPrinter::addDeclResultType(const DeclRef<Decl>& inDeclRef)
     DeclRef<Decl> declRef = inDeclRef;
     if (auto genericDeclRef = declRef.as<GenericDecl>())
     {
-        declRef = m_astBuilder->getSpecializedDeclRef<Decl>(getInner(genericDeclRef), genericDeclRef.getSubst());
+        declRef = m_astBuilder->getMemberDeclRef<Decl>(genericDeclRef, genericDeclRef.getDecl()->inner);
     }
 
     if (declRef.as<ConstructorDecl>())
diff --git a/source/slang/slang-ast-reflect.cpp b/source/slang/slang-ast-reflect.cpp
index b16568d2e..66e57a744 100644
--- a/source/slang/slang-ast-reflect.cpp
+++ b/source/slang/slang-ast-reflect.cpp
@@ -39,7 +39,7 @@ struct ASTConstructAccess
         static void* create(void* context)
         {
             ASTBuilder* astBuilder = (ASTBuilder*)context;
-            return astBuilder->create<T>();
+            return astBuilder->createImpl<T>();
         }
         static void destroy(void* ptr)
         {
diff --git a/source/slang/slang-ast-substitutions.cpp b/source/slang/slang-ast-substitutions.cpp
deleted file mode 100644
index 7b052522e..000000000
--- a/source/slang/slang-ast-substitutions.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-// slang-ast-substitutions.cpp
-#include "slang-ast-builder.h"
-#include <assert.h>
-
-#include "slang-generated-ast-macro.h"
-
-namespace Slang {
-
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Substitutions !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-Substitutions* Substitutions::applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff)
-{
-    SLANG_AST_NODE_VIRTUAL_CALL(Substitutions, applySubstitutionsShallow, (astBuilder, substSet, substOuter, ioDiff))
-}
-
-bool Substitutions::equals(Substitutions* subst)
-{
-    SLANG_AST_NODE_VIRTUAL_CALL(Substitutions, equals, (subst))
-}
-
-HashCode Substitutions::getHashCode() const
-{
-    SLANG_AST_NODE_CONST_VIRTUAL_CALL(Substitutions, getHashCode, ())
-}
-
-Substitutions* Substitutions::_applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff)
-{
-    SLANG_UNUSED(astBuilder);
-    SLANG_UNUSED(substSet);
-    SLANG_UNUSED(substOuter);
-    SLANG_UNUSED(ioDiff);
-    SLANG_UNEXPECTED("Substitutions::_applySubstitutionsShallowOverride not overridden");
-    //return Substitutions*();
-}
-
-bool Substitutions::_equalsOverride(Substitutions* subst)
-{
-    SLANG_UNUSED(subst);
-    SLANG_UNEXPECTED("Substitutions::_equalsOverride not overridden");
-    //return false;
-}
-
-HashCode Substitutions::_getHashCodeOverride() const
-{
-    SLANG_UNEXPECTED("Substitutions::_getHashCodeOverride not overridden");
-    //return HashCode(0);
-}
-
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! GenericSubstitution !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-Substitutions* GenericSubstitution::_applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff)
-{
-    int diff = 0;
-
-    if (substOuter != outer) diff++;
-
-    List<Val*> substArgs;
-    for (auto a : args)
-    {
-        substArgs.add(a->substituteImpl(astBuilder, substSet, &diff));
-    }
-
-    if (!diff) return this;
-
-    (*ioDiff)++;
-
-    auto substSubst = astBuilder->getOrCreateGenericSubstitution(substOuter, genericDecl, substArgs);
-    return substSubst;
-}
-
-bool GenericSubstitution::_equalsOverride(Substitutions* subst)
-{
-    // both must be NULL, or non-NULL
-    if (subst == nullptr)
-        return false;
-    if (this == subst)
-        return true;
-
-    auto genericSubst = as<GenericSubstitution>(subst);
-    if (!genericSubst)
-        return false;
-    if (genericDecl != genericSubst->genericDecl)
-        return false;
-
-    Index argCount = args.getCount();
-    SLANG_RELEASE_ASSERT(args.getCount() == genericSubst->args.getCount());
-    for (Index aa = 0; aa < argCount; ++aa)
-    {
-        if (!args[aa]->equalsVal(genericSubst->args[aa]))
-            return false;
-    }
-
-    if (!outer)
-        return !genericSubst->outer;
-
-    if (!outer->equals(genericSubst->outer))
-        return false;
-
-    return true;
-}
-
-HashCode GenericSubstitution::_getHashCodeOverride() const 
-{
-    HashCode rs = 0;
-    for (auto && v : args)
-    {
-        rs ^= v->getHashCode();
-        rs *= 16777619;
-    }
-    return rs;
-}
-
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ThisTypeSubstitution !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-Substitutions* ThisTypeSubstitution::_applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff)
-{
-    int diff = 0;
-
-    if (substOuter != outer) diff++;
-
-    // NOTE: Must use .as because we must have a smart pointer here to keep in scope.
-    auto substWitness = as<SubtypeWitness>(witness->substituteImpl(astBuilder, substSet, &diff));
-
-    if (!diff) return this;
-
-    (*ioDiff)++;
-    ThisTypeSubstitution* substSubst;
-
-    substSubst = astBuilder->getOrCreateThisTypeSubstitution(interfaceDecl, substWitness, substOuter);
-    return substSubst;
-}
-
-bool ThisTypeSubstitution::_equalsOverride(Substitutions* subst)
-{
-    if (!subst)
-        return false;
-    if (subst == this)
-        return true;
-
-    if (auto thisTypeSubst = as<ThisTypeSubstitution>(subst))
-    {
-        // For our purposes, two this-type substitutions are
-        // equivalent if they have the same type as `This`,
-        // even if the specific witness values they use
-        // might differ.
-        //
-        if (this->interfaceDecl != thisTypeSubst->interfaceDecl)
-            return false;
-
-        if (!this->witness->sub->equals(thisTypeSubst->witness->sub))
-            return false;
-
-        return true;
-    }
-    return false;
-}
-
-HashCode ThisTypeSubstitution::_getHashCodeOverride() const
-{
-    return witness->sub->getHashCode();
-}
-
-} // namespace Slang
diff --git a/source/slang/slang-ast-support-types.cpp b/source/slang/slang-ast-support-types.cpp
index a3df25ce9..6a957e427 100644
--- a/source/slang/slang-ast-support-types.cpp
+++ b/source/slang/slang-ast-support-types.cpp
@@ -68,4 +68,5 @@ UnownedStringSlice getHigherOrderOperatorName(HigherOrderInvokeExpr* expr)
         return UnownedStringSlice("bwd_diff");
     return UnownedStringSlice();
 }
+
 }
diff --git a/source/slang/slang-ast-support-types.h b/source/slang/slang-ast-support-types.h
index 4765d11ec..9140be967 100644
--- a/source/slang/slang-ast-support-types.h
+++ b/source/slang/slang-ast-support-types.h
@@ -28,7 +28,6 @@ namespace Slang
     class Module;
     class Name;
     class Session;
-    class Substitutions;
     class SyntaxVisitor;
     class FuncDecl;
     class Layout;
@@ -50,6 +49,8 @@ namespace Slang
     class Val;
 
     class NodeBase;
+    class LookupDeclRef;
+    class GenericAppDeclRef;
 
 
     template <typename T>
@@ -625,19 +626,27 @@ namespace Slang
 
     struct SubstitutionSet
     {
-        Substitutions* substitutions = nullptr;
-        operator Substitutions*() const
-        {
-            return substitutions;
-        }
+        DeclRefBase* declRef = nullptr;
+        SubstitutionSet() = default;
+        SubstitutionSet(DeclRefBase* declRefBase)
+            :declRef(declRefBase)
+        {}
+        explicit operator bool() const;
+
+        template<typename F>
+        void forEachGenericSubstitution(F func) const;
+
+        template<typename F>
+        void forEachSubstitutionArg(F func) const;
+
+        Type* applyToType(ASTBuilder* astBuilder, Type* type) const;
+        DeclRefBase* applyToDeclRef(ASTBuilder* astBuilder, DeclRefBase* declRef) const;
+
+        LookupDeclRef* findLookupDeclRef() const;
+        GenericAppDeclRef* findGenericAppDeclRef(GenericDecl* genericDecl) const;
+        GenericAppDeclRef* findGenericAppDeclRef() const;
+        DeclRefBase* getInnerMostNodeWithSubstInfo() const;
 
-        SubstitutionSet() {}
-        SubstitutionSet(Substitutions* subst)
-            : substitutions(subst)
-        {
-        }
-        bool equals(const SubstitutionSet& substSet) const;
-        HashCode getHashCode() const;
     };
 
         /// An expression together with (optional) substutions to apply to it
@@ -741,6 +750,8 @@ namespace Slang
         }
     };
 
+    SubstExpr<Expr> applySubstitutionToExpr(SubstitutionSet substSet, Expr* expr);
+
     class ASTBuilder;
 
     template<typename T>
@@ -752,7 +763,6 @@ namespace Slang
     // try to find the concrete decl that satisfies the associatedtype requirement from the
     // concrete type supplied by ThisTypeSubstittution.
     Val* _tryLookupConcreteAssociatedTypeFromThisTypeSubst(ASTBuilder* builder, DeclRef<Decl> declRef);
-    void _printNestedDecl(const Substitutions* substitutions, const Decl* decl, StringBuilder& out);
 
     template<typename T = Decl>
     struct DeclRef
@@ -780,13 +790,12 @@ namespace Slang
         {}
 
         T* getDecl() const;
-        Substitutions* getSubst() const;
 
         Name* getName() const;
         
         SourceLoc getNameLoc() const;
         SourceLoc getLoc() const;
-        DeclRef<ContainerDecl> getParent(ASTBuilder* astBuilder) const;
+        DeclRef<ContainerDecl> getParent() const;
         HashCode getHashCode() const;
         Type* substitute(ASTBuilder* astBuilder, Type* type) const;
 
@@ -823,7 +832,10 @@ namespace Slang
         }
 
         template<typename U>
-        bool equals(DeclRef<U> other) const;
+        bool equals(DeclRef<U> other) const
+        {
+            return declRefBase == other.declRefBase;
+        }
 
         template<typename U>
         bool operator == (DeclRef<U> other) const
@@ -979,17 +991,17 @@ namespace Slang
     struct FilteredMemberRefList
     {
         List<Decl*> const&	m_decls;
-        SubstitutionSet		m_substitutions;
+        DeclRef<Decl>		m_parent;
         MemberFilterStyle   m_filterStyle;
         ASTBuilder* m_astBuilder;
 
         FilteredMemberRefList(
             ASTBuilder* astBuilder,
             List<Decl*> const&	decls,
-            SubstitutionSet		substitutions,
+            DeclRef<Decl>		parent,
             MemberFilterStyle   filterStyle = MemberFilterStyle::All)
             : m_decls(decls)
-            , m_substitutions(substitutions)
+            , m_parent(parent)
             , m_filterStyle(filterStyle)
             , m_astBuilder(astBuilder)
         {}
@@ -1007,7 +1019,7 @@ namespace Slang
         {
              Decl*const* decl = getFilterCursorByIndex<T>(m_filterStyle, m_decls.begin(), m_decls.end(), index);
              SLANG_ASSERT(decl);
-             return _getSpecializedDeclRef(m_astBuilder, (T*)*decl, m_substitutions).template as<T>();
+             return _getMemberDeclRef(m_astBuilder, m_parent, (T*)*decl).template as<T>();
         }
 
         List<DeclRef<T>> toArray() const
@@ -1042,7 +1054,7 @@ namespace Slang
 
             void operator++() { m_ptr = adjustFilterCursor<T>(m_filterStyle, m_ptr + 1, m_end); }
 
-            DeclRef<T> operator*() { return _getSpecializedDeclRef(m_list->m_astBuilder, (T*)*m_ptr, m_list->m_substitutions).template as<T>(); }
+            DeclRef<T> operator*() { return _getMemberDeclRef(m_list->m_astBuilder, m_list->m_parent, (T*)*m_ptr).template as<T>(); }
         };
 
         Iterator begin() const { return Iterator(this, adjustFilterCursor<T>(m_filterStyle, m_decls.begin(), m_decls.end()), m_decls.end(), m_filterStyle); }
@@ -1431,7 +1443,18 @@ namespace Slang
     {
         SLANG_OBJ_CLASS(WitnessTable)
 
-        RequirementDictionary requirementDictionary;
+        const RequirementDictionary& getRequirementDictionary()
+        {
+            if (m_requirementDictionary.getCount() != m_requirements.getCount())
+            {
+                for (Index i = m_requirementDictionary.getCount(); i < m_requirements.getCount(); i++)
+                {
+                    auto& r = m_requirements[i];
+                    m_requirementDictionary.add(r.key, r.value);
+                }
+            }
+            return m_requirementDictionary;
+        }
 
         void add(Decl* decl, RequirementWitness const& witness);
 
@@ -1440,9 +1463,13 @@ namespace Slang
 
         // The type witnessesd by the witness table (a concrete type).
         Type* witnessedType;
-    };
 
-    typedef Dictionary<unsigned int, NodeBase*> AttributeArgumentValueDict;
+        // Satisfying values of each requirement.
+        List<KeyValuePair<Decl*, RequirementWitness>> m_requirements;
+
+        // Cached dictionary for looking up satisfying values.
+        SLANG_UNREFLECTED RequirementDictionary m_requirementDictionary;
+    };
 
     struct SpecializationParam
     {
@@ -1551,6 +1578,7 @@ namespace Slang
     /// Get the operator name from the higher order invoke expr.
     UnownedStringSlice getHigherOrderOperatorName(HigherOrderInvokeExpr* expr);
 
+
 } // namespace Slang
 
 #endif
diff --git a/source/slang/slang-ast-synthesis.cpp b/source/slang/slang-ast-synthesis.cpp
index 65955e815..cb7d338c8 100644
--- a/source/slang/slang-ast-synthesis.cpp
+++ b/source/slang/slang-ast-synthesis.cpp
@@ -134,8 +134,7 @@ Expr* ASTSynthesizer::emitMemberExpr(Type* type, Name* name)
 {
     auto rs = m_builder->create<StaticMemberExpr>();
     auto typeExpr = m_builder->create<SharedTypeExpr>();
-    auto typetype = m_builder->create<TypeType>();
-    typetype->type = type;
+    auto typetype = m_builder->getOrCreate<TypeType>(type);
     typeExpr->type = typetype;
     rs->baseExpression = typeExpr;
     rs->name = name;
diff --git a/source/slang/slang-ast-type.cpp b/source/slang/slang-ast-type.cpp
index ee5d1d40e..13133a7f8 100644
--- a/source/slang/slang-ast-type.cpp
+++ b/source/slang/slang-ast-type.cpp
@@ -1,49 +1,19 @@
 // slang-ast-type.cpp
 #include "slang-ast-builder.h"
+#include "slang-ast-modifier.h"
 #include <assert.h>
 #include <typeinfo>
 
 #include "slang-syntax.h"
 
 #include "slang-generated-ast-macro.h"
-
 namespace Slang {
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Type !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-Type* Type::createCanonicalType()
-{
-    SLANG_AST_NODE_VIRTUAL_CALL(Type, createCanonicalType, ())
-}
-
-bool Type::equals(Type* type)
-{
-    return getCanonicalType()->equalsImpl(type->getCanonicalType());
-}
-
-bool Type::equalsImpl(Type* type)
-{
-    SLANG_AST_NODE_VIRTUAL_CALL(Type, equalsImpl, (type))
-}
-
-bool Type::_equalsImplOverride(Type* type)
-{
-    SLANG_UNUSED(type)
-    SLANG_UNEXPECTED("Type::_equalsImplOverride not overridden");
-    //return false;
-}
-
 Type* Type::_createCanonicalTypeOverride()
 {
-    SLANG_UNEXPECTED("Type::_createCanonicalTypeOverride not overridden");
-    //return Type*();
-}
-
-bool Type::_equalsValOverride(Val* val)
-{
-    if (auto type = dynamicCast<Type>(val))
-        return const_cast<Type*>(this)->equals(type);
-    return false;
+    return as<Type>(defaultResolveImpl());
 }
 
 Val* Type::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
@@ -61,20 +31,6 @@ Val* Type::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst
     return canSubst;
 }
 
-Type* Type::getCanonicalType()
-{
-    Type* et = const_cast<Type*>(this);
-    if (!et->canonicalType)
-    {
-        // TODO(tfoley): worry about thread safety here?
-        auto canType = et->createCanonicalType();
-        et->canonicalType = canType;
-        if (!et->canonicalType)
-            return getASTBuilder()->getErrorType();
-    }
-    return et->canonicalType;
-}
-
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! OverloadGroupType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void OverloadGroupType::_toTextOverride(StringBuilder& out)
@@ -82,21 +38,11 @@ void OverloadGroupType::_toTextOverride(StringBuilder& out)
     out << toSlice("overload group");
 }
 
-bool OverloadGroupType::_equalsImplOverride(Type * /*type*/)
-{
-    return false;
-}
-
 Type* OverloadGroupType::_createCanonicalTypeOverride()
 {
     return this;
 }
 
-HashCode OverloadGroupType::_getHashCodeOverride()
-{
-    return (HashCode)(size_t(this));
-}
-
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! InitializerListType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void InitializerListType::_toTextOverride(StringBuilder& out)
@@ -104,21 +50,11 @@ void InitializerListType::_toTextOverride(StringBuilder& out)
     out << toSlice("initializer list");
 }
 
-bool InitializerListType::_equalsImplOverride(Type * /*type*/)
-{
-    return false;
-}
-
 Type* InitializerListType::_createCanonicalTypeOverride()
 {
     return this;
 }
 
-HashCode InitializerListType::_getHashCodeOverride()
-{
-    return (HashCode)(size_t(this));
-}
-
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ErrorType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void ErrorType::_toTextOverride(StringBuilder& out)
@@ -126,11 +62,6 @@ void ErrorType::_toTextOverride(StringBuilder& out)
     out << toSlice("error");
 }
 
-bool ErrorType::_equalsImplOverride(Type* type)
-{
-    return as<ErrorType>(type);
-}
-
 Type* ErrorType::_createCanonicalTypeOverride()
 {
     return this;
@@ -141,56 +72,21 @@ Val* ErrorType::_substituteImplOverride(ASTBuilder* /* astBuilder */, Substituti
     return this;
 }
 
-HashCode ErrorType::_getHashCodeOverride()
-{
-    return HashCode(size_t(this));
-}
-
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! BottomType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void BottomType::_toTextOverride(StringBuilder& out) { out << toSlice("never"); }
 
-bool BottomType::_equalsImplOverride(Type* type)
-{
-    return as<BottomType>(type);
-}
-
-Type* BottomType::_createCanonicalTypeOverride() { return this; }
-
 Val* BottomType::_substituteImplOverride(
     ASTBuilder* /* astBuilder */, SubstitutionSet /*subst*/, int* /*ioDiff*/)
 {
     return this;
 }
 
-HashCode BottomType::_getHashCodeOverride() { return HashCode(size_t(this)); }
-
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DeclRefType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void DeclRefType::_toTextOverride(StringBuilder& out)
 {
-    out << declRef;
-}
-
-HashCode DeclRefType::_getHashCodeOverride()
-{
-    return (declRef.getHashCode() * 16777619) ^ (HashCode)(typeid(this).hash_code());
-}
-
-bool DeclRefType::_equalsImplOverride(Type * type)
-{
-    if (auto declRefType = as<DeclRefType>(type))
-    {
-        return declRef.equals(declRefType->declRef);
-    }
-    return false;
-}
-
-Type* DeclRefType::_createCanonicalTypeOverride()
-{
-    // A declaration reference is already canonical
-    declRef.substitute(this->getASTBuilder(), this);
-    return this;
+    out << getDeclRef();
 }
 
 Val* maybeSubstituteGenericParam(Val* paramVal, Decl* paramDecl, SubstitutionSet subst, int* ioDiff);
@@ -199,26 +95,47 @@ Val* DeclRefType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSe
 {
     if (!subst) return this;
 
-    // the case we especially care about is when this type references a declaration
-    // of a generic parameter, since that is what we might be substituting...
-    if (auto genericTypeParamDecl = as<GenericTypeParamDecl>(declRef.getDecl()))
+    int diff = 0;
+    DeclRef<Decl> substDeclRef = getDeclRef().substituteImpl(astBuilder, subst, &diff);
+
+    // If this declref type is a direct reference to ThisType or a Generic parameter,
+    // and `subst` provides an argument for it, then we should just return that argument.
+    //
+    if (as<DirectDeclRef>(substDeclRef.declRefBase))
     {
-        if (auto result = maybeSubstituteGenericParam(this, genericTypeParamDecl, subst, ioDiff))
+        if (auto thisDecl = as<ThisTypeDecl>(substDeclRef.getDecl()))
+        {
+            auto lookupDeclRef = subst.findLookupDeclRef();
+            if (lookupDeclRef && lookupDeclRef->getSupDecl() == substDeclRef.getDecl()->parentDecl)
+            {
+                (*ioDiff)++;
+                return lookupDeclRef->getLookupSource();
+            }
+        }
+        else if (as<GenericTypeParamDecl>(substDeclRef.getDecl()) || as<GenericValueParamDecl>(substDeclRef.getDecl()))
         {
-            if (auto substDeclRefType = as<DeclRefType>(result))
+            auto resultVal = maybeSubstituteGenericParam(nullptr, substDeclRef.getDecl(), subst, ioDiff);
+            if (resultVal)
             {
-                // After generic substitution, we may be able to further simplify
-                // by looking up the actual type of an associated type.
-                if (auto satisfyingVal = _tryLookupConcreteAssociatedTypeFromThisTypeSubst(
-                        astBuilder, substDeclRefType->declRef))
-                    return satisfyingVal;
+                (*ioDiff)++;
+                return resultVal;
             }
-            return result;
         }
     }
 
-    int diff = 0;
-    DeclRef<Decl> substDeclRef = declRef.substituteImpl(astBuilder, subst, &diff);
+    // If this type is a reference to an associated type declaration,
+    // and the substitutions provide a "this type" substitution for
+    // the outer interface, then try to replace the type with the
+    // actual value of the associated type for the given implementation.
+    //
+    if (auto satisfyingVal = substDeclRef.declRefBase->resolve())
+    {
+        if (satisfyingVal != getDeclRef())
+        {
+            *ioDiff += 1;
+            return DeclRefType::create(astBuilder, substDeclRef);
+        }
+    }
 
     if (!diff)
         return this;
@@ -226,14 +143,6 @@ Val* DeclRefType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSe
     // Make sure to record the difference!
     *ioDiff += diff;
 
-    // If this type is a reference to an associated type declaration,
-    // and the substitutions provide a "this type" substitution for
-    // the outer interface, then try to replace the type with the
-    // actual value of the associated type for the given implementation.
-    //
-    if (auto satisfyingVal = _tryLookupConcreteAssociatedTypeFromThisTypeSubst(astBuilder, substDeclRef))
-        return satisfyingVal;
-
     // Re-construct the type in case we are using a specialized sub-class
     return DeclRefType::create(astBuilder, substDeclRef);
 }
@@ -254,40 +163,52 @@ BasicExpressionType* ArithmeticExpressionType::_getScalarTypeOverride()
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! BasicExpressionType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-bool BasicExpressionType::_equalsImplOverride(Type * type)
+BasicExpressionType* BasicExpressionType::_getScalarTypeOverride()
 {
-    auto basicType = as<BasicExpressionType>(type);
-    return basicType && basicType->baseType == this->baseType;
+    return this;
 }
 
-Type* BasicExpressionType::_createCanonicalTypeOverride()
+static Val* _getGenericTypeArg(DeclRefBase* declRef, Index i)
 {
-    // A basic type is already canonical, in our setup
-    return this;
+    auto args = findInnerMostGenericArgs(SubstitutionSet(declRef));
+    if (args.getCount() <= i)
+        return nullptr;
+
+    return args[i];
 }
 
-BasicExpressionType* BasicExpressionType::_getScalarTypeOverride()
+static Val* _getGenericTypeArg(DeclRefType* declRefType, Index i)
 {
-    return this;
+    return _getGenericTypeArg(declRefType->getDeclRefBase(), i);
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! TensorViewType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 Type* TensorViewType::getElementType()
 {
-    return as<Type>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[0]);
+    return as<Type>(_getGenericTypeArg(this, 0));
 }
 
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! VectorExpressionType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
+Type* VectorExpressionType::getElementType()
+{
+    return as<Type>(_getGenericTypeArg(this, 0));
+}
+
+IntVal* VectorExpressionType::getElementCount()
+{
+    return as<IntVal>(_getGenericTypeArg(this, 1));
+}
+
 void VectorExpressionType::_toTextOverride(StringBuilder& out)
 {
-    out << toSlice("vector<") << elementType << toSlice(",") << elementCount << toSlice(">");
+    out << toSlice("vector<") << getElementType() << toSlice(",") << getElementCount() << toSlice(">");
 }
 
 BasicExpressionType* VectorExpressionType::_getScalarTypeOverride()
 {
-    return as<BasicExpressionType>(elementType);
+    return as<BasicExpressionType>(getElementType());
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! MatrixExpressionType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -304,24 +225,24 @@ BasicExpressionType* MatrixExpressionType::_getScalarTypeOverride()
 
 Type* MatrixExpressionType::getElementType()
 {
-    return as<Type>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[0]);
+    return as<Type>(_getGenericTypeArg(this, 0));
 }
 
 IntVal* MatrixExpressionType::getRowCount()
 {
-    return as<IntVal>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[1]);
+    return as<IntVal>(_getGenericTypeArg(this, 1));
 }
 
 IntVal* MatrixExpressionType::getColumnCount()
 {
-    return as<IntVal>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[2]);
+    return as<IntVal>(_getGenericTypeArg(this, 2));
 }
 
 Type* MatrixExpressionType::getRowType()
 {
     if (!rowType)
     {
-        rowType = m_astBuilder->getVectorType(getElementType(), getColumnCount());
+        rowType = getCurrentASTBuilder()->getVectorType(getElementType(), getColumnCount());
     }
     return rowType;
 }
@@ -330,12 +251,12 @@ Type* MatrixExpressionType::getRowType()
 
 Type* ArrayExpressionType::getElementType()
 {
-    return as<Type>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[0]);
+    return as<Type>(_getGenericTypeArg(this, 0));
 }
 
 IntVal* ArrayExpressionType::getElementCount()
 {
-    return as<IntVal>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[1]);
+    return as<IntVal>(_getGenericTypeArg(this, 1));
 }
 
 void ArrayExpressionType::_toTextOverride(StringBuilder& out)
@@ -353,7 +274,7 @@ bool ArrayExpressionType::isUnsized()
 {
     if (auto constSize = as<ConstantIntVal>(getElementCount()))
     {
-        if (constSize->value == kUnsizedArrayMagicLength)
+        if (constSize->getValue() == kUnsizedArrayMagicLength)
             return true;
     }
     return false;
@@ -363,27 +284,12 @@ bool ArrayExpressionType::isUnsized()
 
 void TypeType::_toTextOverride(StringBuilder& out)
 {
-    out << toSlice("typeof(") << type << toSlice(")");
-}
-
-bool TypeType::_equalsImplOverride(Type * t)
-{
-    if (auto typeType = as<TypeType>(t))
-    {
-        return t->equals(typeType->type);
-    }
-    return false;
+    out << toSlice("typeof(") << getType() << toSlice(")");
 }
 
 Type* TypeType::_createCanonicalTypeOverride()
 {
-    return getASTBuilder()->getTypeType(type->getCanonicalType());
-}
-
-HashCode TypeType::_getHashCodeOverride()
-{
-    SLANG_UNEXPECTED("TypeType::_getHashCodeOverride should be unreachable");
-    //return HashCode(0);
+    return getCurrentASTBuilder()->getTypeType(getType()->getCanonicalType());
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! GenericDeclRefType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -394,20 +300,6 @@ void GenericDeclRefType::_toTextOverride(StringBuilder& out)
     out << toSlice("<DeclRef<GenericDecl>>");
 }
 
-bool GenericDeclRefType::_equalsImplOverride(Type * type)
-{
-    if (auto genericDeclRefType = as<GenericDeclRefType>(type))
-    {
-        return declRef.equals(genericDeclRefType->declRef);
-    }
-    return false;
-}
-
-HashCode GenericDeclRefType::_getHashCodeOverride()
-{
-    return declRef.getHashCode();
-}
-
 Type* GenericDeclRefType::_createCanonicalTypeOverride()
 {
     return this;
@@ -417,21 +309,7 @@ Type* GenericDeclRefType::_createCanonicalTypeOverride()
 
 void NamespaceType::_toTextOverride(StringBuilder& out)
 {
-    out << toSlice("namespace ") << declRef; 
-}
-
-bool NamespaceType::_equalsImplOverride(Type * type)
-{
-    if (auto namespaceType = as<NamespaceType>(type))
-    {
-        return declRef.equals(namespaceType->declRef);
-    }
-    return false;
-}
-
-HashCode NamespaceType::_getHashCodeOverride()
-{
-    return declRef.getHashCode();
+    out << toSlice("namespace ") << getDeclRef(); 
 }
 
 Type* NamespaceType::_createCanonicalTypeOverride()
@@ -441,7 +319,7 @@ Type* NamespaceType::_createCanonicalTypeOverride()
 
 Type* DifferentialPairType::getPrimalType()
 {
-    return as<Type>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[0]);
+    return as<Type>(_getGenericTypeArg(this, 0));
 }
 
 
@@ -449,51 +327,35 @@ Type* DifferentialPairType::getPrimalType()
 
 Type* PtrTypeBase::getValueType()
 {
-    return as<Type>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[0]);
+    return as<Type>(_getGenericTypeArg(this, 0));
 }
 
 Type* OptionalType::getValueType()
 {
-    return as<Type>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[0]);
+    return as<Type>(_getGenericTypeArg(this, 0));
+}
+
+Type* NativeRefType::getValueType()
+{
+    return as<Type>(_getGenericTypeArg(this, 0));
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! NamedExpressionType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void NamedExpressionType::_toTextOverride(StringBuilder& out)
 {
-    if (declRef.getDecl())
+    if (getDeclRef().getDecl())
     {
-        _printNestedDecl(declRef.getSubst(), declRef.getDecl(), out);
+        getDeclRef().declRefBase->toText(out);
     }
 }
 
-bool NamedExpressionType::_equalsImplOverride(Type * /*type*/)
-{
-    SLANG_UNEXPECTED("NamedExpressionType::_equalsImplOverride should be unreachable");
-    //return false;
-}
-
 Type* NamedExpressionType::_createCanonicalTypeOverride()
 {
-    if (!innerType)
-        innerType = getType(m_astBuilder, declRef);
-    if (innerType)
-        return innerType->getCanonicalType();
-    return nullptr;
-}
-
-HashCode NamedExpressionType::_getHashCodeOverride()
-{
-    // Type equality is based on comparing canonical types,
-    // so the hash code for a type needs to come from the
-    // canonical version of the type. This really means
-    // that `Type::getHashCode()` should dispatch out to
-    // something like `Type::getHashCodeImpl()` on the
-    // canonical version of a type, but it is less invasive
-    // for now (and hopefully equivalent) to just have any
-    // named types automaticlaly route hash-code requests
-    // to their canonical type.
-    return getCanonicalType()->getHashCode();
+    auto canType = getType(getCurrentASTBuilder(), getDeclRef());
+    if (canType)
+        return canType->getCanonicalType();
+    return getCurrentASTBuilder()->getErrorType();
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! FuncType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -533,58 +395,27 @@ void FuncType::_toTextOverride(StringBuilder& out)
     }
     out << ") -> " << getResultType();
 
-    if (!getErrorType()->equals(getASTBuilder()->getBottomType()))
+    if (!getErrorType()->equals(getCurrentASTBuilder()->getBottomType()))
     {
         out << " throws " << getErrorType();
     }
 }
 
-bool FuncType::_equalsImplOverride(Type * type)
-{
-    if (auto funcType = as<FuncType>(type))
-    {
-        auto paramCount = getParamCount();
-        auto otherParamCount = funcType->getParamCount();
-        if (paramCount != otherParamCount)
-            return false;
-
-        for (Index pp = 0; pp < paramCount; ++pp)
-        {
-            auto paramType = getParamType(pp);
-            auto otherParamType = funcType->getParamType(pp);
-            if (!paramType->equals(otherParamType))
-                return false;
-        }
-
-        if (!resultType->equals(funcType->resultType))
-            return false;
-
-        if (!errorType->equals(funcType->errorType))
-            return false;
-
-        // TODO: if we ever introduce other kinds
-        // of qualification on function types, we'd
-        // want to consider it here.
-        return true;
-    }
-    return false;
-}
-
 Val* FuncType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
 
     // result type
-    Type* substResultType = as<Type>(resultType->substituteImpl(astBuilder, subst, &diff));
+    Type* substResultType = as<Type>(getResultType()->substituteImpl(astBuilder, subst, &diff));
 
     // error type
-    Type* substErrorType = as<Type>(errorType->substituteImpl(astBuilder, subst, &diff));
+    Type* substErrorType = as<Type>(getErrorType()->substituteImpl(astBuilder, subst, &diff));
 
     // parameter types
     List<Type*> substParamTypes;
-    for (auto pp : paramTypes)
+    for (Index pp = 0; pp < getParamCount(); pp++ )
     {
-        substParamTypes.add(as<Type>(pp->substituteImpl(astBuilder, subst, &diff)));
+        substParamTypes.add(as<Type>(getParamType(pp)->substituteImpl(astBuilder, subst, &diff)));
     }
 
     // early exit for no change...
@@ -592,138 +423,75 @@ Val* FuncType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet s
         return this;
 
     (*ioDiff)++;
-    FuncType* substType = astBuilder->create<FuncType>();
-    substType->resultType = substResultType;
-    substType->paramTypes = substParamTypes;
-    substType->errorType = substErrorType;
+    FuncType* substType = astBuilder->getFuncType(substParamTypes.getArrayView(), substResultType, substErrorType);
     return substType;
 }
 
 Type* FuncType::_createCanonicalTypeOverride()
 {
     // result type
-    Type* canResultType = resultType->getCanonicalType();
-    Type* canErrorType = errorType->getCanonicalType();
+    Type* canResultType = getResultType()->getCanonicalType();
+    Type* canErrorType = getErrorType()->getCanonicalType();
 
     // parameter types
     List<Type*> canParamTypes;
-    for (auto pp : paramTypes)
+    for (Index pp = 0; pp < getParamCount(); pp++)
     {
-        canParamTypes.add(pp->getCanonicalType());
+        canParamTypes.add(getParamType(pp)->getCanonicalType());
     }
 
-    FuncType* canType = getASTBuilder()->create<FuncType>();
-    canType->resultType = canResultType;
-    canType->paramTypes = canParamTypes;
-    canType->errorType = canErrorType;
+    FuncType* canType = getCurrentASTBuilder()->getFuncType(canParamTypes.getArrayView(), canResultType, canErrorType);
     return canType;
 }
 
-HashCode FuncType::_getHashCodeOverride()
-{
-    HashCode hashCode = getResultType()->getHashCode();
-    Index paramCount = getParamCount();
-    hashCode = combineHash(hashCode, Slang::getHashCode(paramCount));
-    for (Index pp = 0; pp < paramCount; ++pp)
-    {
-        hashCode = combineHash(
-            hashCode,
-            getParamType(pp)->getHashCode());
-    }
-    combineHash(hashCode, getErrorType()->getHashCode());
-    return hashCode;
-}
-
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! TupleType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void TupleType::_toTextOverride(StringBuilder& out)
 {
     out << toSlice("(");
-    for (Index pp = 0; pp < memberTypes.getCount(); ++pp)
+    for (Index pp = 0; pp < getOperandCount(); ++pp)
     {
         if (pp != 0)
             out << toSlice(", ");
-        out << memberTypes[pp];
+        out << getOperand(pp);
     }
     out << toSlice(")");
 }
 
-bool TupleType::_equalsImplOverride(Type * type)
-{
-    if (const auto other = as<TupleType>(type))
-    {
-        auto paramCount = memberTypes.getCount();
-        auto otherParamCount = other->memberTypes.getCount();
-        if (paramCount != otherParamCount)
-            return false;
-
-        for (Index i = 0; i < memberTypes.getCount(); ++i)
-        {
-            if(!memberTypes[i]->equals(other->memberTypes[i]))
-                return false;
-        }
-
-        return true;
-    }
-    return false;
-}
-
 Val* TupleType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
 
     // just recurse into the members
     List<Type*> substMemberTypes;
-    for (auto m : memberTypes)
-        substMemberTypes.add(as<Type>(m->substituteImpl(astBuilder, subst, &diff)));
+    for (Index m = 0; m < getMemberCount(); m++)
+        substMemberTypes.add(as<Type>(getMember(m)->substituteImpl(astBuilder, subst, &diff)));
 
     // early exit for no change...
     if (!diff)
         return this;
 
     (*ioDiff)++;
-    return astBuilder->create<TupleType>(std::move(substMemberTypes));
+    return astBuilder->getTupleType(substMemberTypes);
 }
 
 Type* TupleType::_createCanonicalTypeOverride()
 {
     // member types
     List<Type*> canMemberTypes;
-    for (auto m : memberTypes)
+    for (Index m = 0; m < getMemberCount(); m++)
     {
-        canMemberTypes.add(m->getCanonicalType());
+        canMemberTypes.add(getMember(m)->getCanonicalType());
     }
 
-    return getASTBuilder()->create<TupleType>(std::move(canMemberTypes));
-}
-
-HashCode TupleType::_getHashCodeOverride()
-{
-    HashCode hashCode = Slang::getHashCode(kType);
-    for(auto m : memberTypes)
-        hashCode = combineHash(hashCode, m->getHashCode());
-    return hashCode;
+    return getCurrentASTBuilder()->getTupleType(canMemberTypes);
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ExtractExistentialType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void ExtractExistentialType::_toTextOverride(StringBuilder& out)
 {
-    out << declRef << toSlice(".This");
-}
-
-bool ExtractExistentialType::_equalsImplOverride(Type* type)
-{
-    if (auto extractExistential = as<ExtractExistentialType>(type))
-    {
-        return declRef.equals(extractExistential->declRef);
-    }
-    return false;
-}
-
-HashCode ExtractExistentialType::_getHashCodeOverride()
-{
-    return combineHash(declRef.getHashCode(), originalInterfaceType->getHashCode(), originalInterfaceDeclRef.getHashCode());
+    out << getDeclRef() << toSlice(".This");
 }
 
 Type* ExtractExistentialType::_createCanonicalTypeOverride()
@@ -734,18 +502,16 @@ Type* ExtractExistentialType::_createCanonicalTypeOverride()
 Val* ExtractExistentialType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
-    auto substDeclRef = declRef.substituteImpl(astBuilder, subst, &diff);
-    auto substOriginalInterfaceType = originalInterfaceType->substituteImpl(astBuilder, subst, &diff);
-    auto substOriginalInterfaceDeclRef = originalInterfaceDeclRef.substituteImpl(astBuilder, subst, &diff);
+    auto substDeclRef = getDeclRef().substituteImpl(astBuilder, subst, &diff);
+    auto substOriginalInterfaceType = getOriginalInterfaceType()->substituteImpl(astBuilder, subst, &diff);
+    auto substOriginalInterfaceDeclRef = getOriginalInterfaceDeclRef().substituteImpl(astBuilder, subst, &diff);
     if (!diff)
         return this;
 
     (*ioDiff)++;
 
-    ExtractExistentialType* substValue = astBuilder->create<ExtractExistentialType>();
-    substValue->declRef = substDeclRef;
-    substValue->originalInterfaceType = as<Type>(substOriginalInterfaceType);
-    substValue->originalInterfaceDeclRef = substOriginalInterfaceDeclRef;
+    ExtractExistentialType* substValue = astBuilder->getOrCreate<ExtractExistentialType>(
+        substDeclRef, as<Type>(substOriginalInterfaceType), substOriginalInterfaceDeclRef);
     return substValue;
 }
 
@@ -754,165 +520,47 @@ SubtypeWitness* ExtractExistentialType::getSubtypeWitness()
     if (auto cachedValue = this->cachedSubtypeWitness)
         return cachedValue;
 
-    ExtractExistentialSubtypeWitness* openedWitness = m_astBuilder->create<ExtractExistentialSubtypeWitness>();
-    openedWitness->sub = this;
-    openedWitness->sup = originalInterfaceType;
-    openedWitness->declRef = this->declRef;
-
+    ExtractExistentialSubtypeWitness* openedWitness = getCurrentASTBuilder()->getOrCreate<ExtractExistentialSubtypeWitness>(this, getOriginalInterfaceType(), getDeclRef());
     this->cachedSubtypeWitness = openedWitness;
     return openedWitness;
 }
 
-DeclRef<InterfaceDecl> ExtractExistentialType::getSpecializedInterfaceDeclRef()
+DeclRef<ThisTypeDecl> ExtractExistentialType::getThisTypeDeclRef()
 {
-    if (auto cachedValue = this->cachedSpecializedInterfaceDeclRef)
+    if (auto cachedValue = this->cachedThisTypeDeclRef)
         return cachedValue;
 
-    auto interfaceDecl = originalInterfaceDeclRef.getDecl();
+    auto interfaceDecl = getOriginalInterfaceDeclRef().getDecl();
 
     SubtypeWitness* openedWitness = getSubtypeWitness();
 
-    ThisTypeSubstitution* openedThisType = m_astBuilder->getOrCreateThisTypeSubstitution(
-        interfaceDecl, openedWitness, originalInterfaceDeclRef.getSubst());
-
-    DeclRef<InterfaceDecl> specialiedInterfaceDeclRef = m_astBuilder->getSpecializedDeclRef<InterfaceDecl>(interfaceDecl, openedThisType);
-
-    this->cachedSpecializedInterfaceDeclRef = specialiedInterfaceDeclRef;
-    return specialiedInterfaceDeclRef;
-}
-
-
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! TaggedUnionType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-void TaggedUnionType::_toTextOverride(StringBuilder& out)
-{
-    out << toSlice("__TaggedUnion(");
-    bool first = true;
-    for (auto caseType : caseTypes)
-    {
-        if (!first)
+    ThisTypeDecl* thisTypeDecl = nullptr;
+    for (auto member : interfaceDecl->members)
+        if (as<ThisTypeDecl>(member))
         {
-            out << toSlice(", ");
+            thisTypeDecl = as<ThisTypeDecl>(member);
+            break;
         }
-        first = false;
-
-        out << caseType;
-    }
-    out << toSlice(")");
-}
-
-bool TaggedUnionType::_equalsImplOverride(Type* type)
-{
-    auto taggedUnion = as<TaggedUnionType>(type);
-    if (!taggedUnion)
-        return false;
-
-    auto caseCount = caseTypes.getCount();
-    if (caseCount != taggedUnion->caseTypes.getCount())
-        return false;
-
-    for (Index ii = 0; ii < caseCount; ++ii)
-    {
-        if (!caseTypes[ii]->equals(taggedUnion->caseTypes[ii]))
-            return false;
-    }
-    return true;
-}
-
-HashCode TaggedUnionType::_getHashCodeOverride()
-{
-    HashCode hashCode = 0;
-    for (auto caseType : caseTypes)
-    {
-        hashCode = combineHash(hashCode, caseType->getHashCode());
-    }
-    return hashCode;
-}
-
-Type* TaggedUnionType::_createCanonicalTypeOverride()
-{
-    TaggedUnionType* canType = m_astBuilder->create<TaggedUnionType>();
-
-    for (auto caseType : caseTypes)
-    {
-        auto canCaseType = caseType->getCanonicalType();
-        canType->caseTypes.add(canCaseType);
-    }
-
-    return canType;
-}
+    SLANG_ASSERT(thisTypeDecl);
 
-Val* TaggedUnionType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
-{
-    int diff = 0;
+    DeclRef<ThisTypeDecl> specialiedInterfaceDeclRef = getCurrentASTBuilder()->getLookupDeclRef(openedWitness, thisTypeDecl);
 
-    List<Type*> substCaseTypes;
-    for (auto caseType : caseTypes)
-    {
-        substCaseTypes.add(as<Type>(caseType->substituteImpl(astBuilder, subst, &diff)));
-    }
-    if (!diff)
-        return this;
-
-    (*ioDiff)++;
-
-    TaggedUnionType* substType = astBuilder->create<TaggedUnionType>();
-    substType->caseTypes.swapWith(substCaseTypes);
-    return substType;
+    this->cachedThisTypeDeclRef = specialiedInterfaceDeclRef;
+    return specialiedInterfaceDeclRef;
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ExistentialSpecializedType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void ExistentialSpecializedType::_toTextOverride(StringBuilder& out)
 {
-    out << toSlice("__ExistentialSpecializedType(") << baseType;
-    for (auto arg : args)
+    out << toSlice("__ExistentialSpecializedType(") << getBaseType();
+    for (Index i = 0; i < getArgCount(); i++)
     {
-        out << toSlice(", ") << arg.val;
+        out << toSlice(", ") << getArg(i).val;
     }
     out << toSlice(")");
 }
 
-bool ExistentialSpecializedType::_equalsImplOverride(Type * type)
-{
-    auto other = as<ExistentialSpecializedType>(type);
-    if (!other)
-        return false;
-
-    if (!baseType->equals(other->baseType))
-        return false;
-
-    auto argCount = args.getCount();
-    if (argCount != other->args.getCount())
-        return false;
-
-    for (Index ii = 0; ii < argCount; ++ii)
-    {
-        auto arg = args[ii];
-        auto otherArg = other->args[ii];
-
-        if (!arg.val->equalsVal(otherArg.val))
-            return false;
-
-        if (!areValsEqual(arg.witness, otherArg.witness))
-            return false;
-    }
-    return true;
-}
-
-HashCode ExistentialSpecializedType::_getHashCodeOverride()
-{
-    Hasher hasher;
-    hasher.hashObject(baseType);
-    for (auto arg : args)
-    {
-        hasher.hashObject(arg.val);
-        if (auto witness = arg.witness)
-            hasher.hashObject(witness);
-    }
-    return hasher.getResult();
-}
-
 static Val* _getCanonicalValue(Val* val)
 {
     if (!val)
@@ -928,16 +576,21 @@ static Val* _getCanonicalValue(Val* val)
 
 Type* ExistentialSpecializedType::_createCanonicalTypeOverride()
 {
-    ExistentialSpecializedType* canType = m_astBuilder->create<ExistentialSpecializedType>();
+    ExpandedSpecializationArgs newArgs;
 
-    canType->baseType = baseType->getCanonicalType();
-    for (auto arg : args)
+    for (Index ii = 0; ii < getArgCount(); ++ii)
     {
+        auto arg = getArg(ii);
         ExpandedSpecializationArg canArg;
         canArg.val = _getCanonicalValue(arg.val);
         canArg.witness = _getCanonicalValue(arg.witness);
-        canType->args.add(canArg);
+        newArgs.add(canArg);
     }
+
+    ExistentialSpecializedType* canType = getCurrentASTBuilder()->getOrCreate<ExistentialSpecializedType>(
+        getBaseType()->getCanonicalType(),
+        newArgs);
+
     return canType;
 }
 
@@ -951,11 +604,12 @@ Val* ExistentialSpecializedType::_substituteImplOverride(ASTBuilder* astBuilder,
 {
     int diff = 0;
 
-    auto substBaseType = as<Type>(baseType->substituteImpl(astBuilder, subst, &diff));
+    auto substBaseType = as<Type>(getBaseType()->substituteImpl(astBuilder, subst, &diff));
 
     ExpandedSpecializationArgs substArgs;
-    for (auto arg : args)
+    for (Index ii = 0; ii < getArgCount(); ++ii)
     {
+        auto arg = getArg(ii);
         ExpandedSpecializationArg substArg;
         substArg.val = _substituteImpl(astBuilder, arg.val, subst, &diff);
         substArg.witness = _substituteImpl(astBuilder, arg.witness, subst, &diff);
@@ -967,96 +621,22 @@ Val* ExistentialSpecializedType::_substituteImplOverride(ASTBuilder* astBuilder,
 
     (*ioDiff)++;
 
-    ExistentialSpecializedType* substType = astBuilder->create<ExistentialSpecializedType>();
-    substType->baseType = substBaseType;
-    substType->args = substArgs;
+    ExistentialSpecializedType* substType = astBuilder->getOrCreate<ExistentialSpecializedType>(substBaseType, substArgs);
     return substType;
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ThisType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-void ThisType::_toTextOverride(StringBuilder& out)
-{
-    out << interfaceDeclRef << toSlice(".This");
-}
-
-bool ThisType::_equalsImplOverride(Type * type)
-{
-    auto other = as<ThisType>(type);
-    if (!other)
-        return false;
-
-    if (!interfaceDeclRef.equals(other->interfaceDeclRef))
-        return false;
-
-    return true;
-}
-
-HashCode ThisType::_getHashCodeOverride()
-{
-    return combineHash(
-        HashCode(typeid(*this).hash_code()),
-        interfaceDeclRef.getHashCode());
-}
-
-Type* ThisType::_createCanonicalTypeOverride()
+InterfaceDecl* ThisType::getInterfaceDecl()
 {
-    ThisType* canType = m_astBuilder->create<ThisType>();
-
-    // TODO: need to canonicalize the decl-ref
-    canType->interfaceDeclRef = interfaceDeclRef;
-    return canType;
-}
-
-Val* ThisType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
-{
-    int diff = 0;
-
-    auto substInterfaceDeclRef = interfaceDeclRef.substituteImpl(astBuilder, subst, &diff);
-
-    auto thisTypeSubst = findThisTypeSubstitution(subst.substitutions, substInterfaceDeclRef.getDecl());
-    if (thisTypeSubst)
-    {
-        return thisTypeSubst->witness->sub;
-    }
-
-    if (!diff)
-        return this;
-
-    (*ioDiff)++;
-
-    ThisType* substType = m_astBuilder->create<ThisType>();
-    substType->interfaceDeclRef = substInterfaceDeclRef;
-    return substType;
+    return dynamicCast<InterfaceDecl>(getDeclRefBase()->getDecl()->parentDecl);
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! AndType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void AndType::_toTextOverride(StringBuilder& out)
 {
-    out << left << toSlice(" & ") << right;
-}
-
-bool AndType::_equalsImplOverride(Type * type)
-{
-    auto other = as<AndType>(type);
-    if (!other)
-        return false;
-
-    if(!left->equals(other->left))
-        return false;
-    if(!right->equals(other->right))
-        return false;
-
-    return true;
-}
-
-HashCode AndType::_getHashCodeOverride()
-{
-    Hasher hasher;
-    hasher.hashObject(left);
-    hasher.hashObject(right);
-    return hasher.getResult();
+    out << getLeft() << toSlice(" & ") << getRight();
 }
 
 Type* AndType::_createCanonicalTypeOverride()
@@ -1094,9 +674,9 @@ Type* AndType::_createCanonicalTypeOverride()
     // right now, in the name of getting something up and running.
     //
 
-    auto canLeft = left->getCanonicalType();
-    auto canRight = right->getCanonicalType();
-    auto canType = m_astBuilder->getAndType(canLeft, canRight);
+    auto canLeft = getLeft()->getCanonicalType();
+    auto canRight = getRight()->getCanonicalType();
+    auto canType = getCurrentASTBuilder()->getAndType(canLeft, canRight);
     return canType;
 }
 
@@ -1104,15 +684,15 @@ Val* AndType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet su
 {
     int diff = 0;
 
-    auto substLeft  = as<Type>(left ->substituteImpl(astBuilder, subst, &diff));
-    auto substRight = as<Type>(right->substituteImpl(astBuilder, subst, &diff));
+    auto substLeft  = as<Type>(getLeft()->substituteImpl(astBuilder, subst, &diff));
+    auto substRight = as<Type>(getRight()->substituteImpl(astBuilder, subst, &diff));
 
     if(!diff)
         return this;
 
     (*ioDiff)++;
 
-    auto substType = m_astBuilder->getAndType(substLeft, substRight);
+    auto substType = getCurrentASTBuilder()->getAndType(substLeft, substRight);
     return substType;
 }
 
@@ -1120,83 +700,35 @@ Val* AndType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet su
 
 void ModifiedType::_toTextOverride(StringBuilder& out)
 {
-    for( auto modifier : modifiers )
+    for( Index i = 0; i < getModifierCount(); i++ )
     {
-        modifier->toText(out);
+        getModifier(i)->toText(out);
         out.appendChar(' ');
     }
-    base->toText(out);
-}
-
-bool ModifiedType::_equalsImplOverride(Type* type)
-{
-    auto other = as<ModifiedType>(type);
-    if(!other)
-        return false;
-
-    if(!base->equals(other->base))
-        return false;
-
-    // TODO: Eventually we need to put the `modifiers` into
-    // a canonical ordering as part of creation of a `ModifiedType`,
-    // so that two instances that apply the same modifiers to
-    // the same type will have those modifiers in a matching order.
-    //
-    // The simplest way to achieve that ordering *for now* would
-    // be to sort the array by the integer AST node type tag.
-    // That approach would of course not scale to modifiers that
-    // have any operands of their own.
-    //
-    // Note that we would *also* need the logic that creates a
-    // `ModifiedType` to detect when the base type is itself a
-    // `ModifiedType` and produce a single `ModifiedType` with
-    // a combined list of modifiers and a non-`ModifiedType` as
-    // its base type.
-    //
-    auto modifierCount = modifiers.getCount();
-    if(modifierCount != other->modifiers.getCount())
-        return false;
-
-    for( Index i = 0; i < modifierCount; ++i )
-    {
-        auto thisModifier = this->modifiers[i];
-        auto otherModifier = other->modifiers[i];
-        if(!thisModifier->equalsVal(otherModifier))
-            return false;
-    }
-    return true;
-}
-
-HashCode ModifiedType::_getHashCodeOverride()
-{
-    Hasher hasher;
-    hasher.hashObject(base);
-    for( auto modifier : modifiers )
-    {
-        hasher.hashObject(modifier);
-    }
-    return hasher.getResult();
+    getBase()->toText(out);
 }
 
 Type* ModifiedType::_createCanonicalTypeOverride()
 {
-    ModifiedType* canonical = m_astBuilder->create<ModifiedType>();
-    canonical->base = base->getCanonicalType();
-    for( auto modifier : modifiers )
+    List<Val*> modifiers;
+    for (Index i = 0; i < getModifierCount(); ++i)
     {
-        canonical->modifiers.add(modifier);
+        auto modifier = this->getModifier(i);
+        modifiers.add(modifier);
     }
+    ModifiedType* canonical = getCurrentASTBuilder()->getOrCreate<ModifiedType>(getBase()->getCanonicalType(), modifiers.getArrayView());
     return canonical;
 }
 
 Val* ModifiedType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
-    Type* substBase = as<Type>(base->substituteImpl(astBuilder, subst, &diff));
+    Type* substBase = as<Type>(getBase()->substituteImpl(astBuilder, subst, &diff));
 
     List<Val*> substModifiers;
-    for( auto modifier : modifiers )
+    for (Index i = 0; i < getModifierCount(); ++i)
     {
+        auto modifier = this->getModifier(i);
         auto substModifier = modifier->substituteImpl(astBuilder, subst, &diff);
         substModifiers.add(substModifier);
     }
@@ -1206,12 +738,49 @@ Val* ModifiedType::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionS
 
     *ioDiff = 1;
 
-    ModifiedType* substType = m_astBuilder->create<ModifiedType>();
-    substType->base = substBase;
-    substType->modifiers = _Move(substModifiers);
+    ModifiedType* substType = getCurrentASTBuilder()->getOrCreate<ModifiedType>(substBase, substModifiers.getArrayView());
     return substType;
 }
 
+BaseType BasicExpressionType::getBaseType() const
+{
+    auto builtinType = getDeclRef().getDecl()->findModifier<BuiltinTypeModifier>();
+    return builtinType->tag;
+}
+
+FeedbackType::Kind FeedbackType::getKind() const
+{
+    auto magicMod = getDeclRef().getDecl()->findModifier<MagicTypeModifier>();
+    return FeedbackType::Kind(magicMod->tag);
+}
+
+TextureFlavor ResourceType::getFlavor() const
+{
+    auto magicMod = getDeclRef().getDecl()->findModifier<MagicTypeModifier>();
+    return TextureFlavor(magicMod->tag);
+}
+
+SamplerStateFlavor SamplerStateType::getFlavor() const
+{
+    auto magicMod = getDeclRef().getDecl()->findModifier<MagicTypeModifier>();
+    return SamplerStateFlavor(magicMod->tag);
+}
+
+Type* BuiltinGenericType::getElementType() const
+{
+    return as<Type>(_getGenericTypeArg(getDeclRefBase(), 0));
+}
+
+Type* ResourceType::getElementType()
+{
+    return as<Type>(_getGenericTypeArg(this, 0));
+}
+
+Val* TextureTypeBase::getSampleCount()
+{
+    return as<Type>(_getGenericTypeArg(this, 1));
+}
+
 Type* removeParamDirType(Type* type)
 {
     for (auto paramDirType = as<ParamDirectionType>(type); paramDirType;)
diff --git a/source/slang/slang-ast-type.h b/source/slang/slang-ast-type.h
index b32d62404..8948f742c 100644
--- a/source/slang/slang-ast-type.h
+++ b/source/slang/slang-ast-type.h
@@ -16,8 +16,6 @@ class OverloadGroupType : public Type
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
     Type* _createCanonicalTypeOverride();
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
 };
 
 // The type of an initializer-list expression (before it has
@@ -29,8 +27,6 @@ class InitializerListType : public Type
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
     Type* _createCanonicalTypeOverride();
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
 };
 
 // The type of an expression that was erroneous
@@ -41,8 +37,6 @@ class ErrorType : public Type
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
     Type* _createCanonicalTypeOverride();
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 };
 
@@ -53,31 +47,28 @@ class BottomType : public Type
 
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
-    Type* _createCanonicalTypeOverride();
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 };
 
 // A type that takes the form of a reference to some declaration
-class DeclRefType : public Type 
+class DeclRefType : public Type
 {
     SLANG_AST_CLASS(DeclRefType)
 
-    DeclRef<Decl> declRef;
-
     static DeclRefType* create(ASTBuilder* astBuilder, DeclRef<Decl> declRef);
 
+    DeclRef<Decl> getDeclRef() const { return DeclRef<Decl>(as<DeclRefBase>(getOperand(0))); }
+    DeclRefBase* getDeclRefBase() const { return as<DeclRefBase>(getOperand(0)); }
+
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
     Type* _createCanonicalTypeOverride();
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 
     DeclRefType(DeclRefBase* declRefBase)
-        : declRef(declRefBase)
-    {}
+    {
+        setOperands(declRefBase);
+    }
 };
 
 // Base class for types that can be used in arithmetic expressions
@@ -95,18 +86,15 @@ class BasicExpressionType : public ArithmeticExpressionType
 {
     SLANG_AST_CLASS(BasicExpressionType)
 
-    BaseType baseType;
+    BaseType getBaseType() const;
 
     // Overrides should be public so base classes can access
-    Type* _createCanonicalTypeOverride();
-    bool _equalsImplOverride(Type* type);
     BasicExpressionType* _getScalarTypeOverride();
 
-protected:
-    BasicExpressionType(
-        Slang::BaseType baseType)
-        : baseType(baseType)
-    {}
+    BasicExpressionType(DeclRefBase* inDeclRef)
+    {
+        setOperands(inDeclRef);
+    }
 };
 
 // Base type for things that are built in to the compiler,
@@ -127,7 +115,7 @@ class FeedbackType : public BuiltinType
         MipRegionUsed,          /// SAMPLER_FEEDBACK_MIP_REGION_USED
     };
 
-    Kind kind;
+    Kind getKind() const;
 };
 
 // Resources that contain "elements" that can be fetched
@@ -135,37 +123,24 @@ class ResourceType : public BuiltinType
 {
     SLANG_ABSTRACT_AST_CLASS(ResourceType)
 
-    // The type that results from fetching an element from this resource
-    Type* elementType = nullptr;
-
-    // Shape and access level information for this resource type
-    TextureFlavor flavor;
+    TextureFlavor getFlavor() const;
 
     TextureFlavor::Shape getBaseShape()
     {
-        return flavor.getBaseShape();
+        return getFlavor().getBaseShape();
     }
-    bool isMultisample() { return flavor.isMultisample(); }
-    bool isArray() { return flavor.isArray(); }
-    SlangResourceShape getShape() const { return flavor.getShape(); }
-    SlangResourceAccess getAccess() { return flavor.getAccess(); }
+    bool isMultisample() { return getFlavor().isMultisample(); }
+    bool isArray() { return getFlavor().isArray(); }
+    SlangResourceShape getShape() const { return getFlavor().getShape(); }
+    SlangResourceAccess getAccess() { return getFlavor().getAccess(); }
+    Type* getElementType();
 };
 
 class TextureTypeBase : public ResourceType 
 {
     SLANG_ABSTRACT_AST_CLASS(TextureTypeBase)
 
-    // The sampleCount parameter of a RWTexture*MS resource.
-    Val* sampleCount = nullptr;
-protected:
-    TextureTypeBase(TextureFlavor inFlavor, Type* inElementType, Val* inSampleCount = nullptr)
-    {
-        elementType = inElementType;
-        flavor = inFlavor;
-        sampleCount = inSampleCount;
-    }
-
-    Val* getSampleCount() const { return sampleCount; }
+    Val* getSampleCount();
 };
 
 
@@ -173,11 +148,6 @@ protected:
 class TextureType : public TextureTypeBase 
 {
     SLANG_AST_CLASS(TextureType)
-
-protected:
-    TextureType(TextureFlavor flavor, Type* elementType, Val* inSampleCount = nullptr)
-        : TextureTypeBase(flavor, elementType, inSampleCount)
-    {}
 };
 
 
@@ -186,37 +156,20 @@ protected:
 class TextureSamplerType : public TextureTypeBase 
 {
     SLANG_AST_CLASS(TextureSamplerType)
-
-protected:
-    TextureSamplerType(TextureFlavor flavor, Type* elementType)
-        : TextureTypeBase(flavor, elementType)
-    {}
 };
 
 // This is a base type for `image*` types, as they exist in GLSL
 class GLSLImageType : public TextureTypeBase 
 {
     SLANG_AST_CLASS(GLSLImageType)
-
-protected:
-    GLSLImageType(
-        TextureFlavor flavor,
-        Type* elementType)
-        : TextureTypeBase(flavor, elementType)
-    {}
 };
 
 class SamplerStateType : public BuiltinType 
 {
     SLANG_AST_CLASS(SamplerStateType)
 
-    // What flavor of sampler state is this
-    SamplerStateFlavor flavor;
-
-    SamplerStateType(SamplerStateFlavor inFlavor)
-    {
-        flavor = inFlavor;
-    }
+    // Returns flavor of sampler state of this type.
+    SamplerStateFlavor getFlavor() const;
 };
 
 // Other cases of generic types known to the compiler
@@ -224,9 +177,7 @@ class BuiltinGenericType : public BuiltinType
 {
     SLANG_AST_CLASS(BuiltinGenericType)
 
-    Type* elementType = nullptr;
-
-    Type* getElementType() { return elementType; }
+    Type* getElementType() const;
 };
 
 // Types that behave like pointers, in that they can be
@@ -297,7 +248,6 @@ class HLSLConsumeStructuredBufferType : public HLSLStructuredBufferTypeBase
     SLANG_AST_CLASS(HLSLConsumeStructuredBufferType)
 };
 
-
 class HLSLPatchType : public BuiltinType 
 {
     SLANG_AST_CLASS(HLSLPatchType)
@@ -396,7 +346,6 @@ class VaryingParameterGroupType : public ParameterGroupType
 class ConstantBufferType : public UniformParameterGroupType 
 {
     SLANG_AST_CLASS(ConstantBufferType)
-    ConstantBufferType(Type* elementType) { SLANG_UNUSED(elementType); }
 };
 
 
@@ -435,11 +384,7 @@ class ParameterBlockType : public UniformParameterGroupType
 class ArrayExpressionType : public DeclRefType 
 {
     SLANG_AST_CLASS(ArrayExpressionType)
-    ArrayExpressionType(Type* inElementType, IntVal* inElementCount)
-    {
-        SLANG_UNUSED(inElementType);
-        SLANG_UNUSED(inElementCount);
-    }
+
     bool isUnsized();
     void _toTextOverride(StringBuilder& out);
     Type* getElementType();
@@ -453,21 +398,16 @@ class TypeType : public Type
 {
     SLANG_AST_CLASS(TypeType)
 
-    // The type that this is the type of...
-    Type* type = nullptr;
-
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
     Type* _createCanonicalTypeOverride();
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
 
-protected:
-    TypeType(Type* type)
-        : type(type)
-    {}
+    Type* getType() { return as<Type>(getOperand(0)); }
 
-    
+    TypeType(Type* type)
+    {
+        setOperands(type);
+    }
 };
 
 // A differential pair type, e.g., `__DifferentialPair<T>`
@@ -487,20 +427,12 @@ class VectorExpressionType : public ArithmeticExpressionType
 {
     SLANG_AST_CLASS(VectorExpressionType)
 
-    // The type of vector elements.
-    // As an invariant, this should be a basic type or an alias.
-    Type* elementType = nullptr;
-
-    // The number of elements
-    IntVal* elementCount = nullptr;
-
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
     BasicExpressionType* _getScalarTypeOverride();
 
-    VectorExpressionType(Type* inElementType, IntVal* inElementCount)
-       : elementType(inElementType), elementCount(inElementCount)
-    {}
+    Type* getElementType();
+    IntVal* getElementCount();
 };
 
 // A matrix type, e.g., `matrix<T,R,C>`
@@ -519,9 +451,7 @@ class MatrixExpressionType : public ArithmeticExpressionType
     BasicExpressionType* _getScalarTypeOverride();
 
 private:
-    Type* rowType = nullptr;
-
-    MatrixExpressionType(Type*, IntVal*, IntVal*) {}
+    SLANG_UNREFLECTED Type* rowType = nullptr;
 };
 
 class TensorViewType : public BuiltinType
@@ -529,8 +459,6 @@ class TensorViewType : public BuiltinType
     SLANG_AST_CLASS(TensorViewType)
 
     Type* getElementType();
-private:
-    TensorViewType(Type*) {}
 };
 
 // Base class for built in string types
@@ -561,6 +489,7 @@ class DynamicType : public BuiltinType
 class EnumTypeType : public BuiltinType 
 {
     SLANG_AST_CLASS(EnumTypeType)
+
     // TODO: provide accessors for the declaration, the "tag" type, etc.
 };
 
@@ -640,22 +569,16 @@ class NamedExpressionType : public Type
 {
     SLANG_AST_CLASS(NamedExpressionType)
 
-    DeclRef<TypeDefDecl> declRef;
-    Type* innerType = nullptr;
+    DeclRef<TypeDefDecl> getDeclRef() { return as<DeclRefBase>(getOperand(0)); }
 
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
     Type* _createCanonicalTypeOverride();
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
-
-protected:
-    NamedExpressionType(
-        DeclRef<TypeDefDecl> declRef)
-        : declRef(declRef)
-    {}
-
 
+    NamedExpressionType(DeclRef<TypeDefDecl> inDeclRef)
+    {
+        setOperands(inDeclRef);
+    }
 };
 
 // A function type is defined by its parameter types
@@ -666,27 +589,24 @@ class FuncType : public Type
 
     // Construct a unary function
     FuncType(Type* paramType, Type* resultType, Type* errorType)
-        : paramTypes{{paramType}}, resultType{resultType}, errorType{errorType}
-    {}
-
-    FuncType(List<Type*> parameters, Type* result, Type* error)
-        : paramTypes(std::move(parameters)), resultType(result), errorType(error)
-    {}
+    {
+        setOperands(paramType, resultType, errorType);
+    }
 
-    // TODO: We may want to preserve parameter names
-    // in the list here, just so that we can print
-    // out friendly names when printing a function
-    // type, even if they don't affect the actual
-    // semantic type underneath.
+    FuncType(ArrayView<Type*> parameters, Type* result, Type* error)
+    {
+        for (auto paramType : parameters)
+            m_operands.add(ValNodeOperand(paramType));
+        m_operands.add(ValNodeOperand(result));
+        m_operands.add(ValNodeOperand(error));
+    }
 
-    List<Type*> paramTypes;
-    Type* resultType = nullptr;
-    Type* errorType = nullptr;
+    OperandView<Type> getParamTypes() { return OperandView<Type>(this, 0, getOperandCount() - 2); }
 
-    Index getParamCount() { return paramTypes.getCount(); }
-    Type* getParamType(Index index) { return paramTypes[index]; }
-    Type* getResultType() { return resultType; }
-    Type* getErrorType() { return errorType; }
+    Index getParamCount() { return m_operands.getCount() - 2; }
+    Type* getParamType(Index index) { return as<Type>(getOperand(index)); }
+    Type* getResultType() { return as<Type>(getOperand(m_operands.getCount() - 2)); }
+    Type* getErrorType() { return as<Type>(getOperand(m_operands.getCount() - 1)); }
 
     ParameterDirection getParamDirection(Index index);
 
@@ -694,8 +614,6 @@ class FuncType : public Type
     void _toTextOverride(StringBuilder& out);
     Type* _createCanonicalTypeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
 };
 
 // A tuple is a product of its member types
@@ -704,21 +622,19 @@ class TupleType : public Type
     SLANG_AST_CLASS(TupleType)
 
     // Construct a unary tupletion
-    TupleType(List<Type*> memberTypes)
-        : memberTypes(std::move(memberTypes))
-    {}
-
-    auto getMemberCount() { return memberTypes.getCount(); } const
-    auto& getMember(Index i) { return memberTypes[i]; }
+    TupleType(ArrayView<Type*> memberTypes)
+    {
+        for (auto t : memberTypes)
+            m_operands.add(ValNodeOperand(t));
+    }
 
-    List<Type*> memberTypes;
+    auto getMemberCount() const { return getOperandCount(); }
+    Type* getMember(Index i) const { return as<Type>(getOperand(i)); }
 
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
     Type* _createCanonicalTypeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
 };
 
 // The "type" of an expression that names a generic declaration.
@@ -726,21 +642,16 @@ class GenericDeclRefType : public Type
 {
     SLANG_AST_CLASS(GenericDeclRefType)
 
-    DeclRef<GenericDecl> declRef;
-
-    DeclRef<GenericDecl> const& getDeclRef() const { return declRef; }
+    DeclRef<GenericDecl> getDeclRef() const { return as<DeclRefBase>(getOperand(0)); }
 
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
     Type* _createCanonicalTypeOverride();
 
-protected:
-    GenericDeclRefType(
-        DeclRef<GenericDecl> declRef)
-        : declRef(declRef)
-    {}
+    GenericDeclRefType(DeclRef<GenericDecl> declRef)
+    {
+        setOperands(declRef);
+    }
 };
 
 // The "type" of a reference to a module or namespace
@@ -748,14 +659,15 @@ class NamespaceType : public Type
 {
     SLANG_AST_CLASS(NamespaceType)
 
-    DeclRef<NamespaceDeclBase> declRef;
+    DeclRef<NamespaceDeclBase> getDeclRef() const { return as<DeclRefBase>(getOperand(0)); }
 
-    DeclRef<NamespaceDeclBase> const& getDeclRef() const { return declRef; }
+    NamespaceType(DeclRef<NamespaceDeclBase> inDeclRef)
+    {
+        setOperands(inDeclRef);
+    }
 
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
     Type* _createCanonicalTypeOverride();
 };
 
@@ -765,25 +677,33 @@ class ExtractExistentialType : public Type
 {
     SLANG_AST_CLASS(ExtractExistentialType)
 
-    DeclRef<VarDeclBase> declRef;
+    DeclRef<VarDeclBase> getDeclRef() const { return as<DeclRefBase>(getOperand(0)); }
 
     // A reference to the original interface this type is known
     // to be a subtype of.
     //
-    Type* originalInterfaceType;
-    DeclRef<InterfaceDecl> originalInterfaceDeclRef;
+    Type* getOriginalInterfaceType() { return as<Type>(getOperand(1)); }
+    DeclRef<InterfaceDecl> getOriginalInterfaceDeclRef() { return as<DeclRefBase>(getOperand(2)); }
+
+    ExtractExistentialType(
+        DeclRef<VarDeclBase> inDeclRef,
+        Type* inOriginalInterfaceType,
+        DeclRef<InterfaceDecl> inOriginalInterfaceDeclRef)
+    {
+        setOperands(inDeclRef, inOriginalInterfaceType, inOriginalInterfaceDeclRef);
+    }
 
 // Following fields will not be reflected (and thus won't be serialized, etc.)
 SLANG_UNREFLECTED
 
-    // A cached decl-ref to the original interface above, with
-    // a this-type substitution that refers to the type extracted here.
+    // A cached decl-ref to the original interface's ThisType Decl, with
+    // a witness that refers to the type extracted here.
     //
     // This field is optional and can be filled in on-demand. It does *not*
     // represent part of the logical value of this `Type`, and should not
     // be serialized, included in hashes, etc.
     //
-    DeclRef<InterfaceDecl> cachedSpecializedInterfaceDeclRef;
+    DeclRef<ThisTypeDecl> cachedThisTypeDeclRef;
 
     // A cached pointer to a witness that shows how this type is a subtype
     // of `originalInterfaceType`.
@@ -792,8 +712,6 @@ SLANG_UNREFLECTED
 
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
     Type* _createCanonicalTypeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 
@@ -803,62 +721,54 @@ SLANG_UNREFLECTED
         ///
     SubtypeWitness* getSubtypeWitness();
 
-        /// Get a interface decl-ref for the original interface specialized to this type
-        /// (using a type-type substitution).
+        /// Get a decl-ref to the interface's ThisType decl, which represents a substitutable type
+        /// from which lookup can be performed.
         ///
         /// This operation may create the decl-ref on demand and cache it.
         ///
-    DeclRef<InterfaceDecl> getSpecializedInterfaceDeclRef();
-};
-
-    /// A tagged union of zero or more other types.
-class TaggedUnionType : public Type 
-{
-    SLANG_AST_CLASS(TaggedUnionType)
-
-        /// The distinct "cases" the tagged union can store.
-        ///
-        /// For each type in this array, the array index is the
-        /// tag value for that case.
-        ///
-    List<Type*> caseTypes;
-
-    // Overrides should be public so base classes can access
-    void _toTextOverride(StringBuilder& out);
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
-    Type* _createCanonicalTypeOverride();
-    Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    DeclRef<ThisTypeDecl> getThisTypeDeclRef();
 };
 
 class ExistentialSpecializedType : public Type 
 {
     SLANG_AST_CLASS(ExistentialSpecializedType)
 
-    Type* baseType = nullptr;
-    ExpandedSpecializationArgs args;
+    Type* getBaseType() { return as<Type>(getOperand(0)); }
+    ExpandedSpecializationArg getArg(Index i)
+    {
+        ExpandedSpecializationArg arg;
+        arg.val = getOperand(i * 2 + 1);
+        arg.witness = getOperand(i * 2 + 2);
+        return arg;
+    }
+    Index getArgCount() { return (getOperandCount() - 1) / 2; }
+
+    ExistentialSpecializedType(
+        Type* inBaseType,
+        ExpandedSpecializationArgs const& inArgs)
+    {
+        m_operands.add(ValNodeOperand(inBaseType));
+        for (auto arg : inArgs)
+        {
+            m_operands.add(ValNodeOperand(arg.val));
+            m_operands.add(ValNodeOperand(arg.witness));
+        }
+    }
 
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
     Type* _createCanonicalTypeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 };
 
     /// The type of `this` within a polymorphic declaration
-class ThisType : public Type 
+class ThisType : public DeclRefType
 {
     SLANG_AST_CLASS(ThisType)
 
-    DeclRef<InterfaceDecl> interfaceDeclRef;
+    ThisType(DeclRefBase* declRef) : DeclRefType(declRef) {}
 
-    // Overrides should be public so base classes can access
-    void _toTextOverride(StringBuilder& out);
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
-    Type* _createCanonicalTypeOverride();
-    Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    InterfaceDecl* getInterfaceDecl();
 };
 
     /// The type of `A & B` where `A` and `B` are types
@@ -868,17 +778,16 @@ class AndType : public Type
 {
     SLANG_AST_CLASS(AndType)
 
-    Type* left;
-    Type* right;
-
+    Type* getLeft() { return as<Type>(getOperand(0)); }
+    Type* getRight() { return as<Type>(getOperand(1)); }
+    
     AndType(Type* leftType, Type* rightType)
-        : left(leftType), right(rightType)
-    {}
+    {
+        setOperands(leftType, rightType);
+    }
 
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
     Type* _createCanonicalTypeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 };
@@ -887,22 +796,32 @@ class ModifiedType : public Type
 {
     SLANG_AST_CLASS(ModifiedType)
 
-    Type* base;
-    List<Val*> modifiers;
+    Type* getBase()
+    {
+        return as<Type>(getOperand(0));
+    }
+
+    Index getModifierCount() { return getOperandCount() - 1; }
+    Val* getModifier(Index index) { return getOperand(index + 1); }
+
+    ModifiedType(Type* inBase, ArrayView<Val*> inModifiers)
+    {
+        m_operands.add(ValNodeOperand(inBase));
+        for (auto modifier : inModifiers)
+            m_operands.add(ValNodeOperand(modifier));
+    }
 
     template<typename T>
     T* findModifier()
     {
-        for (auto v : modifiers)
-            if (auto rs = as<T>(v))
+        for (Index i = 1; i < getOperandCount(); i++)
+            if (auto rs = as<T>(getOperand(i)))
                 return rs;
         return nullptr;
     }
 
     // Overrides should be public so base classes can access
     void _toTextOverride(StringBuilder& out);
-    bool _equalsImplOverride(Type* type);
-    HashCode _getHashCodeOverride();
     Type* _createCanonicalTypeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 };
diff --git a/source/slang/slang-ast-val.cpp b/source/slang/slang-ast-val.cpp
index b45300af8..056577eb0 100644
--- a/source/slang/slang-ast-val.cpp
+++ b/source/slang/slang-ast-val.cpp
@@ -6,9 +6,47 @@
 #include "slang-generated-ast-macro.h"
 #include "slang-diagnostics.h"
 #include "slang-syntax.h"
+#include "slang-ast-val.h"
 
 namespace Slang {
 
+
+bool ValNodeDesc::operator==(ValNodeDesc const& that) const
+{
+    if (hashCode != that.hashCode) return false;
+    if (type != that.type) return false;
+    if (operands.getCount() != that.operands.getCount()) return false;
+    for (Index i = 0; i < operands.getCount(); ++i)
+    {
+        // Note: we are comparing the operands directly for identity
+        // (pointer equality) rather than doing the `Val`-level
+        // equality check.
+        //
+        // The rationale here is that nodes that will be created
+        // via a `NodeDesc` *should* all be going through the
+        // deduplication path anyway, as should their operands.
+        // 
+        if (operands[i].values.nodeOperand != that.operands[i].values.nodeOperand) return false;
+    }
+    return true;
+}
+
+void ValNodeDesc::init()
+{
+    Hasher hasher;
+    hasher.hashValue(Int(type));
+    for (Index i = 0; i < operands.getCount(); ++i)
+    {
+        // Note: we are hashing the raw pointer value rather
+        // than the content of the value node. This is done
+        // to match the semantics implemented for `==` on
+        // `NodeDesc`.
+        //
+        hasher.hashValue(operands[i].values.nodeOperand);
+    }
+    hashCode = hasher.getResult();
+}
+
 Val* Val::substitute(ASTBuilder* astBuilder, SubstitutionSet subst)
 {
     if (!subst) return this;
@@ -21,14 +59,103 @@ Val* Val::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioD
     SLANG_AST_NODE_VIRTUAL_CALL(Val, substituteImpl, (astBuilder, subst, ioDiff))
 }
 
-bool Val::equalsVal(Val* val)
+void Val::toText(StringBuilder& out)
 {
-    SLANG_AST_NODE_VIRTUAL_CALL(Val, equalsVal, (val))
+    SLANG_AST_NODE_VIRTUAL_CALL(Val, toText, (out))
 }
 
-void Val::toText(StringBuilder& out)
+Val* Val::_resolveImplOverride() 
 {
-    SLANG_AST_NODE_VIRTUAL_CALL(Val, toText, (out))
+    SLANG_UNEXPECTED("Val::_resolveImplOverride not overridden");
+}
+
+Val* Val::resolveImpl()
+{
+    SLANG_AST_NODE_VIRTUAL_CALL(Val, resolveImpl, ());
+}
+
+Val* Val::resolve()
+{
+    auto astBuilder = getCurrentASTBuilder();
+
+    // If we are not in a proper checking context, just return the previously resolved val.
+    if (!astBuilder)
+        return m_resolvedVal? m_resolvedVal : this;
+    if (m_resolvedVal && m_resolvedValEpoch == getCurrentASTBuilder()->getEpoch())
+    {
+        SLANG_ASSERT(as<Val>(m_resolvedVal));
+        return m_resolvedVal;
+    }
+
+    // Update epoch now to avoid infinite recursion.
+    m_resolvedValEpoch = getCurrentASTBuilder()->getEpoch();
+    m_resolvedVal = this;
+    m_resolvedVal = resolveImpl();
+
+    // Check if we are resolved to an existing Val in the AST cache.
+    ValNodeDesc newDesc;
+    newDesc.type = m_resolvedVal->astNodeType;
+    for (auto operand : m_resolvedVal->m_operands)
+    {
+        if (operand.kind == ValNodeOperandKind::ValNode)
+        {
+            auto valOperand = as<Val>(operand.values.nodeOperand);
+            if (valOperand)
+            {
+                operand.values.nodeOperand = valOperand->resolve();
+            }
+        }
+        newDesc.operands.add(operand);
+    }
+    newDesc.init();
+
+    NodeBase* existingNode = nullptr;
+    if (astBuilder->m_cachedNodes.tryGetValue(newDesc, existingNode))
+        m_resolvedVal = as<Val>(existingNode);
+
+#ifdef _DEBUG
+    if (m_resolvedVal->_debugUID > 0 && this->_debugUID < 0)
+    {
+        //SLANG_ASSERT_FAILURE("should not be modifying stdlib vals outside of stdlib checking.");
+    }
+#endif
+    return m_resolvedVal;
+}
+
+ValNodeDesc Val::getDesc()
+{
+    ValNodeDesc desc;
+    desc.type = astNodeType;
+    for (auto operand : m_operands)
+        desc.operands.add(operand);
+    desc.init();
+    return desc;
+}
+
+Val* Val::defaultResolveImpl()
+{
+    // Default resolve implementation is to recursively resolve all operands, and lookup in deduplication cache.
+    ValNodeDesc newDesc;
+    newDesc.type = astNodeType;
+    for (auto operand : m_operands)
+    {
+        if (operand.kind == ValNodeOperandKind::ValNode)
+        {
+            auto valOperand = as<Val>(operand.values.nodeOperand);
+            if (valOperand)
+            {
+                operand.values.nodeOperand = valOperand->resolve();
+            }
+        }
+        newDesc.operands.add(operand);
+    }
+    newDesc.init();
+    auto astBuilder = getCurrentASTBuilder();
+
+    NodeBase* existingNode = nullptr;
+    if (astBuilder->m_cachedNodes.tryGetValue(newDesc, existingNode))
+        return as<Val>(existingNode);
+    return this;
 }
 
 String Val::toString()
@@ -40,7 +167,7 @@ String Val::toString()
 
 HashCode Val::getHashCode()
 {
-    SLANG_AST_NODE_VIRTUAL_CALL(Val, getHashCode, ())
+    return Slang::getHashCode(resolve());
 }
 
 Val* Val::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
@@ -52,124 +179,84 @@ Val* Val::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst,
     return this;
 }
 
-bool Val::_equalsValOverride(Val* val)
-{
-    SLANG_UNUSED(val);
-    SLANG_UNEXPECTED("Val::_equalsValOverride not overridden");
-    //return false;
-}
-
 void Val::_toTextOverride(StringBuilder& out)
 {
     SLANG_UNUSED(out);
     SLANG_UNEXPECTED("Val::_toStringOverride not overridden");
 }
 
-HashCode Val::_getHashCodeOverride()
-{
-    SLANG_UNEXPECTED("Val::_getHashCodeOverride not overridden");
-    //return HashCode(0);
-}
-
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ConstantIntVal !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-bool ConstantIntVal::_equalsValOverride(Val* val)
-{
-    if (auto intVal = as<ConstantIntVal>(val))
-        return value == intVal->value;
-    return false;
-}
-
 void ConstantIntVal::_toTextOverride(StringBuilder& out)
 {
-    out << value;
-}
-
-HashCode ConstantIntVal::_getHashCodeOverride()
-{
-    return (HashCode)value;
+    out << getValue();
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! GenericParamIntVal !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-bool GenericParamIntVal::_equalsValOverride(Val* val)
-{
-    if (auto genericParamVal = as<GenericParamIntVal>(val))
-    {
-        return declRef.equals(genericParamVal->declRef);
-    }
-    return false;
-}
-
 void GenericParamIntVal::_toTextOverride(StringBuilder& out)
 {
-    Name* name = declRef.getName();
+    Name* name = getDeclRef().getName();
     if (name)
     {
         out << name->text;
     }
 }
 
-HashCode GenericParamIntVal::_getHashCodeOverride()
-{
-    return declRef.getHashCode() ^ HashCode(0xFFFF);
-}
-
 Val* maybeSubstituteGenericParam(Val* paramVal, Decl* paramDecl, SubstitutionSet subst, int* ioDiff)
 {
     // search for a substitution that might apply to us
-    for (auto s = subst.substitutions; s; s = s->getOuter())
+    auto outerGeneric = as<GenericDecl>(paramDecl->parentDecl);
+    if (!outerGeneric)
+        return paramVal;
+
+    GenericAppDeclRef* genAppArgs = subst.findGenericAppDeclRef(outerGeneric);
+    if (!genAppArgs)
     {
-        auto genSubst = as<GenericSubstitution>(s);
-        if (!genSubst)
-            continue;
-
-        // the generic decl associated with the substitution list must be
-        // the generic decl that declared this parameter
-        auto genericDecl = genSubst->getGenericDecl();
-        if (genericDecl != paramDecl->parentDecl)
-            continue;
-
-        // In some cases, we construct a `DeclRef` to a `GenericDecl`
-        // (or a declaration under one) that only includes argument
-        // values for a prefix of the parameters of the generic.
-        //
-        // If we aren't careful, we could end up indexing into the
-        // argument list past the available range.
-        //
-        Count argCount = genSubst->getArgs().getCount();
+        return paramVal;
+    }
 
-        Count argIndex = 0;
-        for (auto m : genericDecl->members)
+    auto args = genAppArgs->getArgs();
+
+    // In some cases, we construct a `DeclRef` to a `GenericDecl`
+    // (or a declaration under one) that only includes argument
+    // values for a prefix of the parameters of the generic.
+    //
+    // If we aren't careful, we could end up indexing into the
+    // argument list past the available range.
+    //
+    Count argCount = args.getCount();
+
+    Count argIndex = 0;
+    for (auto m : outerGeneric->members)
+    {
+        // If we have run out of arguments, then we can stop
+        // iterating over the parameters, because `this`
+        // parameter will not be replaced with anything by
+        // the substituion.
+        //
+        if (argIndex >= argCount)
         {
-            // If we have run out of arguments, then we can stop
-            // iterating over the parameters, because `this`
-            // parameter will not be replaced with anything by
-            // the substituion.
-            //
-            if (argIndex >= argCount)
-            {
-                return paramVal;
-            }
+            return paramVal;
+        }
 
 
-            if (m == paramDecl)
-            {
-                // We've found it, so return the corresponding specialization argument
-                (*ioDiff)++;
-                return genSubst->getArgs()[argIndex];
-            }
-            else if (const auto typeParam = as<GenericTypeParamDecl>(m))
-            {
-                argIndex++;
-            }
-            else if (const auto valParam = as<GenericValueParamDecl>(m))
-            {
-                argIndex++;
-            }
-            else
-            {
-            }
+        if (m == paramDecl)
+        {
+            // We've found it, so return the corresponding specialization argument
+            (*ioDiff)++;
+            return args[argIndex];
+        }
+        else if (const auto typeParam = as<GenericTypeParamDecl>(m))
+        {
+            argIndex++;
+        }
+        else if (const auto valParam = as<GenericValueParamDecl>(m))
+        {
+            argIndex++;
+        }
+        else
+        {
         }
     }
 
@@ -180,7 +267,7 @@ Val* maybeSubstituteGenericParam(Val* paramVal, Decl* paramDecl, SubstitutionSet
 
 Val* GenericParamIntVal::_substituteImplOverride(ASTBuilder* /* astBuilder */, SubstitutionSet subst, int* ioDiff)
 {
-    if (auto result = maybeSubstituteGenericParam(this, declRef.getDecl(), subst, ioDiff))
+    if (auto result = maybeSubstituteGenericParam(this, getDeclRef().getDecl(), subst, ioDiff))
         return result;
 
     return this;
@@ -188,21 +275,11 @@ Val* GenericParamIntVal::_substituteImplOverride(ASTBuilder* /* astBuilder */, S
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ErrorIntVal !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-bool ErrorIntVal::_equalsValOverride(Val* val)
-{
-    return as<ErrorIntVal>(val);
-}
-
 void ErrorIntVal::_toTextOverride(StringBuilder& out)
 {
     out << toSlice("<error>");
 }
 
-HashCode ErrorIntVal::_getHashCodeOverride()
-{
-    return HashCode(typeid(this).hash_code());
-}
-
 Val* ErrorIntVal::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     SLANG_UNUSED(astBuilder);
@@ -211,97 +288,110 @@ Val* ErrorIntVal::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSe
     return this;
 }
 
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ErrorIntVal !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-// TODO: should really have a `type.cpp` and a `witness.cpp`
-
-bool TypeEqualityWitness::_equalsValOverride(Val* val)
-{
-    auto otherWitness = as<TypeEqualityWitness>(val);
-    if (!otherWitness)
-        return false;
-    return sub->equals(otherWitness->sub);
-}
-
 Val* TypeEqualityWitness::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int * ioDiff)
 {
-    TypeEqualityWitness* rs = astBuilder->create<TypeEqualityWitness>();
-    rs->sub = as<Type>(sub->substituteImpl(astBuilder, subst, ioDiff));
-    rs->sup = as<Type>(sup->substituteImpl(astBuilder, subst, ioDiff));
+    auto type = as<Type>(getSub()->substituteImpl(astBuilder, subst, ioDiff));
+    TypeEqualityWitness* rs = astBuilder->getOrCreate<TypeEqualityWitness>(type, type);
     return rs;
 }
 
 void TypeEqualityWitness::_toTextOverride(StringBuilder& out)
 {
-    out << toSlice("TypeEqualityWitness(") << sub << toSlice(")");
-}
-
-HashCode TypeEqualityWitness::_getHashCodeOverride()
-{
-    return sub->getHashCode();
+    out << toSlice("TypeEqualityWitness(") << getSub() << toSlice(")");
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DeclaredSubtypeWitness !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-bool DeclaredSubtypeWitness::_equalsValOverride(Val* val)
+Val* DeclaredSubtypeWitness::_resolveImplOverride()
 {
-    auto otherWitness = as<DeclaredSubtypeWitness>(val);
-    if (!otherWitness)
-        return false;
+    auto resolvedDeclRef = getDeclRef().declRefBase->resolve();
+    if (auto resolvedVal = as<SubtypeWitness>(resolvedDeclRef))
+        return resolvedVal;
 
-    return sub->equals(otherWitness->sub)
-        && sup->equals(otherWitness->sup)
-        && declRef.equals(otherWitness->declRef);
+    auto newSub = as<Type>(getSub()->resolve());
+    auto newSup = as<Type>(getSup()->resolve());
+
+    // If we are trying to lookup for a witness that A<:B from a witness(A<:B), we
+    // can just return the witness itself.
+    if (auto lookupDeclRef = as<LookupDeclRef>(resolvedDeclRef))
+    {
+        auto witnessToLookupFrom = lookupDeclRef->getWitness();
+        if (witnessToLookupFrom->getSub()->equals(newSub) &&
+            witnessToLookupFrom->getSup()->equals(newSup))
+            return witnessToLookupFrom;
+    }
+    auto newDeclRef = as<DeclRefBase>(resolvedDeclRef);
+    if (!newDeclRef)
+        newDeclRef = getDeclRef().declRefBase;
+    if (newSub != getSub() || newSup != getSup() || newDeclRef != getDeclRef())
+    {
+        return getCurrentASTBuilder()->getDeclaredSubtypeWitness(newSub, newSup, newDeclRef);
+    }
+    return this;
 }
 
 Val* DeclaredSubtypeWitness::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int * ioDiff)
 {
-    if (auto genConstraintDeclRef = declRef.as<GenericTypeConstraintDecl>())
+    if (auto genConstraintDeclRef = getDeclRef().as<GenericTypeConstraintDecl>())
     {
-        auto genConstraintDecl = genConstraintDeclRef.getDecl();
+        auto genericDecl = as<GenericDecl>(getDeclRef().getDecl()->parentDecl);
+        if (!genericDecl)
+            goto breakLabel;
 
         // search for a substitution that might apply to us
-        for (auto s = subst.substitutions; s; s = s->getOuter())
+        auto args = tryGetGenericArguments(subst, genericDecl);
+        if (args.getCount() == 0)
+            goto breakLabel;
+
+        bool found = false;
+        Index index = 0;
+        for (auto m : genericDecl->members)
         {
-            if (auto genericSubst = as<GenericSubstitution>(s))
+            if (auto constraintParam = as<GenericTypeConstraintDecl>(m))
             {
-                // the generic decl associated with the substitution list must be
-                // the generic decl that declared this parameter
-                auto genericDecl = genericSubst->getGenericDecl();
-                if (genericDecl != genConstraintDecl->parentDecl)
-                    continue;
-
-                bool found = false;
-                Index index = 0;
-                for (auto m : genericDecl->members)
+                if (constraintParam == getDeclRef().getDecl())
                 {
-                    if (auto constraintParam = as<GenericTypeConstraintDecl>(m))
-                    {
-                        if (constraintParam == declRef.getDecl())
-                        {
-                            found = true; 
-                            break;
-                        }
-                        index++;
-                    }
-                }
-                if (found)
-                {
-                    (*ioDiff)++;
-                    auto ordinaryParamCount = genericDecl->getMembersOfType<GenericTypeParamDecl>().getCount() +
-                        genericDecl->getMembersOfType<GenericValueParamDecl>().getCount();
-                    SLANG_ASSERT(index + ordinaryParamCount < genericSubst->getArgs().getCount());
-                    return genericSubst->getArgs()[index + ordinaryParamCount];
+                    found = true;
+                    break;
                 }
+                index++;
+            }
+        }
+        if (found)
+        {
+            auto ordinaryParamCount = genericDecl->getMembersOfType<GenericTypeParamDecl>().getCount() +
+                genericDecl->getMembersOfType<GenericValueParamDecl>().getCount();
+            if (index + ordinaryParamCount < args.getCount())
+            {
+                (*ioDiff)++;
+                return args[index + ordinaryParamCount];
+            }
+            else
+            {
+                // When the `subst` represents a partial substitution, we may not have a corresponding argument.
+                // In this case we just return the original witness.
+                //
+                goto breakLabel;
             }
         }
     }
+    else if (auto thisTypeConstraintDeclRef = getDeclRef().as<ThisTypeConstraintDecl>())
+    {
+        auto lookupSubst = subst.findLookupDeclRef();
+        if (lookupSubst && lookupSubst->getSupDecl() == thisTypeConstraintDeclRef.getDecl()->getInterfaceDecl())
+        {
+            (*ioDiff)++;
+            return lookupSubst->getWitness();
+        }
+    }
+
+breakLabel:;
 
     // Perform substitution on the constituent elements.
     int diff = 0;
-    auto substSub = as<Type>(sub->substituteImpl(astBuilder, subst, &diff));
-    auto substSup = as<Type>(sup->substituteImpl(astBuilder, subst, &diff));
-    auto substDeclRef = declRef.substituteImpl(astBuilder, subst, &diff);
+    auto substSub = as<Type>(getSub()->substituteImpl(astBuilder, subst, &diff));
+    auto substSup = as<Type>(getSup()->substituteImpl(astBuilder, subst, &diff));
+    
     if (!diff)
         return this;
 
@@ -317,7 +407,7 @@ Val* DeclaredSubtypeWitness::_substituteImplOverride(ASTBuilder* astBuilder, Sub
     // so we'll need to change this location in the code if we ever clean
     // up the hierarchy.
     //
-    if (auto substTypeConstraintDecl = as<GenericTypeConstraintDecl>(substDeclRef.getDecl()))
+    if (auto substTypeConstraintDecl = as<GenericTypeConstraintDecl>(getDeclRef().getDecl()))
     {
         if (auto substAssocTypeDecl = as<AssocTypeDecl>(substTypeConstraintDecl->parentDecl))
         {
@@ -326,12 +416,12 @@ Val* DeclaredSubtypeWitness::_substituteImplOverride(ASTBuilder* astBuilder, Sub
                 // At this point we have a constraint decl for an associated type,
                 // and we nee to see if we are dealing with a concrete substitution
                 // for the interface around that associated type.
-                if (auto thisTypeSubst = findThisTypeSubstitution(substDeclRef.getSubst(), interfaceDecl))
+                if (auto thisTypeWitness = findThisTypeWitness(subst, interfaceDecl))
                 {
                     // We need to look up the declaration that satisfies
                     // the requirement named by the associated type.
                     Decl* requirementKey = substTypeConstraintDecl;
-                    RequirementWitness requirementWitness = tryLookUpRequirementWitness(astBuilder, thisTypeSubst->witness, requirementKey);
+                    RequirementWitness requirementWitness = tryLookUpRequirementWitness(astBuilder, thisTypeWitness, requirementKey);
                     switch (requirementWitness.getFlavor())
                     {
                         default:
@@ -348,6 +438,7 @@ Val* DeclaredSubtypeWitness::_substituteImplOverride(ASTBuilder* astBuilder, Sub
         }
     }
 
+    auto substDeclRef = getDeclRef().substituteImpl(astBuilder, subst, &diff);
     auto rs = astBuilder->getDeclaredSubtypeWitness(
         substSub, substSup, substDeclRef);
     return rs;
@@ -355,34 +446,17 @@ Val* DeclaredSubtypeWitness::_substituteImplOverride(ASTBuilder* astBuilder, Sub
 
 void DeclaredSubtypeWitness::_toTextOverride(StringBuilder& out)
 {
-    out << toSlice("DeclaredSubtypeWitness(") << sub << toSlice(", ") << sup << toSlice(", ") << declRef << toSlice(")");
-}
-
-HashCode DeclaredSubtypeWitness::_getHashCodeOverride()
-{
-    return declRef.getHashCode();
+    out << toSlice("DeclaredSubtypeWitness(") << getSub() << toSlice(", ") << getSup() << toSlice(", ") << getDeclRef() << toSlice(")");
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! TransitiveSubtypeWitness !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-bool TransitiveSubtypeWitness::_equalsValOverride(Val* val)
-{
-    auto otherWitness = as<TransitiveSubtypeWitness>(val);
-    if (!otherWitness)
-        return false;
-
-    return sub->equals(otherWitness->sub)
-        && sup->equals(otherWitness->sup)
-        && subToMid->equalsVal(otherWitness->subToMid)
-        && midToSup->equalsVal(otherWitness->midToSup);
-}
-
 Val* TransitiveSubtypeWitness::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int * ioDiff)
 {
     int diff = 0;
 
-    SubtypeWitness* substSubToMid = as<SubtypeWitness>(subToMid->substituteImpl(astBuilder, subst, &diff));
-    SubtypeWitness* substMidToSup = as<SubtypeWitness>(midToSup->substituteImpl(astBuilder, subst, &diff));
+    SubtypeWitness* substSubToMid = as<SubtypeWitness>(getSubToMid()->substituteImpl(astBuilder, subst, &diff));
+    SubtypeWitness* substMidToSup = as<SubtypeWitness>(getMidToSup()->substituteImpl(astBuilder, subst, &diff));
 
     // If nothing changed, then we can bail out early.
     if (!diff)
@@ -407,16 +481,7 @@ void TransitiveSubtypeWitness::_toTextOverride(StringBuilder& out)
     // witnesses, and rely on them to print
     // the starting and ending types.
     
-    out << toSlice("TransitiveSubtypeWitness(") << subToMid << toSlice(", ") << midToSup << toSlice(")");
-}
-
-HashCode TransitiveSubtypeWitness::_getHashCodeOverride()
-{
-    auto hash = sub->getHashCode();
-    hash = combineHash(hash, sup->getHashCode());
-    hash = combineHash(hash, subToMid->getHashCode());
-    hash = combineHash(hash, midToSup->getHashCode());
-    return hash;
+    out << toSlice("TransitiveSubtypeWitness(") << getSubToMid() << toSlice(", ") << getMidToSup() << toSlice(")");
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ExtractFromConjunctionSubtypeWitness !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -425,9 +490,9 @@ Val* ExtractFromConjunctionSubtypeWitness::_substituteImplOverride(ASTBuilder* a
 {
     int diff = 0;
 
-    auto substSub = as<Type>(sub->substituteImpl(astBuilder, subst, &diff));
-    auto substSup = as<Type>(sup->substituteImpl(astBuilder, subst, &diff));
-    auto substWitness = as<SubtypeWitness>(conjunctionWitness->substituteImpl(astBuilder, subst, &diff));
+    auto substSub = as<Type>(getSub()->substituteImpl(astBuilder, subst, &diff));
+    auto substSup = as<Type>(getSup()->substituteImpl(astBuilder, subst, &diff));
+    auto substWitness = as<SubtypeWitness>(getConjunctionWitness()->substituteImpl(astBuilder, subst, &diff));
 
     // If nothing changed, then we can bail out early.
     if (!diff)
@@ -447,138 +512,34 @@ Val* ExtractFromConjunctionSubtypeWitness::_substituteImplOverride(ASTBuilder* a
     // simplification logic as needed.
     //
     return astBuilder->getExtractFromConjunctionSubtypeWitness(
-        substSub, substSup, substWitness, indexInConjunction);
+        substSub, substSup, substWitness, getIndexInConjunction());
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ExtractExistentialSubtypeWitness !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-bool ExtractExistentialSubtypeWitness::_equalsValOverride(Val* val)
-{
-    if (auto extractWitness = as<ExtractExistentialSubtypeWitness>(val))
-    {
-        return declRef.equals(extractWitness->declRef);
-    }
-    return false;
-}
-
 void ExtractExistentialSubtypeWitness::_toTextOverride(StringBuilder& out)
 {
-    out << toSlice("extractExistentialValue(") << declRef << toSlice(")");
-}
-
-HashCode ExtractExistentialSubtypeWitness::_getHashCodeOverride()
-{
-    return declRef.getHashCode();
+    out << toSlice("extractExistentialValue(") << getDeclRef() << toSlice(")");
 }
 
 Val* ExtractExistentialSubtypeWitness::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
 
-    auto substDeclRef = declRef.substituteImpl(astBuilder, subst, &diff);
-    auto substSub = as<Type>(sub->substituteImpl(astBuilder, subst, &diff));
-    auto substSup = as<Type>(sup->substituteImpl(astBuilder, subst, &diff));
+    auto substDeclRef = getDeclRef().substituteImpl(astBuilder, subst, &diff);
+    auto substSub = as<Type>(getSub()->substituteImpl(astBuilder, subst, &diff));
+    auto substSup = as<Type>(getSup()->substituteImpl(astBuilder, subst, &diff));
 
     if (!diff)
         return this;
 
     (*ioDiff)++;
 
-    ExtractExistentialSubtypeWitness* substValue = astBuilder->create<ExtractExistentialSubtypeWitness>();
-    substValue->declRef = substDeclRef;
-    substValue->sub = substSub;
-    substValue->sup = substSup;
+    ExtractExistentialSubtypeWitness* substValue = astBuilder->getOrCreate<ExtractExistentialSubtypeWitness>(
+        substSub, substSup, substDeclRef);
     return substValue;
 }
 
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! TaggedUnionSubtypeWitness !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-bool TaggedUnionSubtypeWitness::_equalsValOverride(Val* val)
-{
-    auto taggedUnionWitness = as<TaggedUnionSubtypeWitness>(val);
-    if (!taggedUnionWitness)
-        return false;
-
-    auto caseCount = caseWitnesses.getCount();
-    if (caseCount != taggedUnionWitness->caseWitnesses.getCount())
-        return false;
-
-    for (Index ii = 0; ii < caseCount; ++ii)
-    {
-        if (!caseWitnesses[ii]->equalsVal(taggedUnionWitness->caseWitnesses[ii]))
-            return false;
-    }
-
-    return true;
-}
-
-void TaggedUnionSubtypeWitness::_toTextOverride(StringBuilder& out)
-{
-    out << toSlice("TaggedUnionSubtypeWitness(");
-    bool first = true;
-    for (auto caseWitness : caseWitnesses)
-    {
-        if (!first)
-        {
-            out << toSlice(", ");
-        }
-        first = false;
-
-        out << caseWitness;
-    }
-    out << toSlice(")");
-}
-
-HashCode TaggedUnionSubtypeWitness::_getHashCodeOverride()
-{
-    HashCode hash = 0;
-    for (auto caseWitness : caseWitnesses)
-    {
-        hash = combineHash(hash, caseWitness->getHashCode());
-    }
-    return hash;
-}
-
-Val* TaggedUnionSubtypeWitness::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
-{
-    int diff = 0;
-
-    auto substSub = as<Type>(sub->substituteImpl(astBuilder, subst, &diff));
-    auto substSup = as<Type>(sup->substituteImpl(astBuilder, subst, &diff));
-
-    List<SubtypeWitness*> substCaseWitnesses;
-    for (auto caseWitness : caseWitnesses)
-    {
-        substCaseWitnesses.add(
-            as<SubtypeWitness>(caseWitness->substituteImpl(astBuilder, subst, &diff)));
-    }
-
-    if (!diff)
-        return this;
-
-    (*ioDiff)++;
-
-    TaggedUnionSubtypeWitness* substWitness = astBuilder->create<TaggedUnionSubtypeWitness>();
-    substWitness->sub = substSub;
-    substWitness->sup = substSup;
-    substWitness->caseWitnesses.swapWith(substCaseWitnesses);
-    return substWitness;
-}
-
-bool ConjunctionSubtypeWitness::_equalsValOverride(Val* val)
-{
-    auto other = as<ConjunctionSubtypeWitness>(val);
-    if (!other)
-        return false;
-
-    for (Index i = 0; i < kComponentCount; ++i)
-    {
-        if (!other->componentWitnesses[i]) return false;
-        if (!other->componentWitnesses[i]->equalsVal(componentWitnesses[i])) return false;
-    }
-    return true;
-}
-
 void ConjunctionSubtypeWitness::_toTextOverride(StringBuilder& out)
 {
     out << "ConjunctionSubtypeWitness(";
@@ -586,34 +547,23 @@ void ConjunctionSubtypeWitness::_toTextOverride(StringBuilder& out)
     {
         if (i != 0) out << ",";
 
-        auto w = componentWitnesses[i];
+        auto w = getComponentWitness(i);
         if (w) out << w;
     }
     out << ")";
 }
 
-HashCode ConjunctionSubtypeWitness::_getHashCodeOverride()
-{
-    HashCode result = 0;
-    for (Index i = 0; i < kComponentCount; ++i)
-    {
-        auto w = componentWitnesses[i];
-        if (w) result = combineHash(result, w->getHashCode());
-    }
-    return result;
-}
-
 Val* ConjunctionSubtypeWitness::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
     Val* substComponentWitnesses[kComponentCount];
 
-    auto substSub = as<Type>(sub->substituteImpl(astBuilder, subst, &diff));
-    auto substSup = as<Type>(sup->substituteImpl(astBuilder, subst, &diff));
+    auto substSub = as<Type>(getSub()->substituteImpl(astBuilder, subst, &diff));
+    auto substSup = as<Type>(getSup()->substituteImpl(astBuilder, subst, &diff));
 
     for (Index i = 0; i < kComponentCount; ++i)
     {
-        auto w = componentWitnesses[i];
+        auto w = getComponentWitness(i);
         substComponentWitnesses[i] = w ? w->substituteImpl(astBuilder, subst, &diff) : nullptr;
     }
 
@@ -630,65 +580,25 @@ Val* ConjunctionSubtypeWitness::_substituteImplOverride(ASTBuilder* astBuilder,
     auto result = astBuilder->getConjunctionSubtypeWitness(
         substSub,
         substSup,
-        componentWitnesses[0],
-        componentWitnesses[1]);
+        as<SubtypeWitness>(substComponentWitnesses[0]),
+        as<SubtypeWitness>(substComponentWitnesses[1]));
     return result;
 }
 
-bool ExtractFromConjunctionSubtypeWitness::_equalsValOverride(Val* val)
-{
-    if (auto other = as<ExtractFromConjunctionSubtypeWitness>(val))
-    {
-        if(!sub->equals(other->sub)) return false;
-        if(!sup->equals(other->sup)) return false;
-        if(indexInConjunction != other->indexInConjunction) return false;
-
-        return true;
-    }
-    return false;
-}
-
 void ExtractFromConjunctionSubtypeWitness::_toTextOverride(StringBuilder& out)
 {
     out << "ExtractFromConjunctionSubtypeWitness(";
-    if (conjunctionWitness)
-        out << conjunctionWitness;
-    if (sub)
-        out << sub;
+    if (getConjunctionWitness())
+        out << getConjunctionWitness();
+    if (getSub())
+        out << getSub();
     out << ",";
-    if (sup)
-        out << sup;
-    out << "," << indexInConjunction;
+    if (getSup())
+        out << getSup();
+    out << "," << getIndexInConjunction();
     out << ")";
 }
 
-HashCode ExtractFromConjunctionSubtypeWitness::_getHashCodeOverride()
-{
-    return combineHash(
-        conjunctionWitness ? conjunctionWitness->getHashCode() : 0,
-        sub ? sub->getHashCode() : 0,
-        sup ? sup->getHashCode() : 0,
-        indexInConjunction);
-}
-
-// ModifierVal
-
-bool ModifierVal::_equalsValOverride(Val* val)
-{
-    // TODO: This is assuming we can fully deduplicate the values that represent
-    // modifiers, which may not actually be the case if there are multiple modules
-    // being combined that use different `ASTBuilder`s.
-    //
-    return this == val;
-}
-
-HashCode ModifierVal::_getHashCodeOverride()
-{
-    Hasher hasher;
-    hasher.hashValue((void*) this);
-    return hasher.getResult();
-}
-
 // UNormModifierVal
 
 void UNormModifierVal::_toTextOverride(StringBuilder& out)
@@ -735,48 +645,14 @@ Val* NoDiffModifierVal::_substituteImplOverride(ASTBuilder* astBuilder, Substitu
 
 // PolynomialIntVal
 
-bool PolynomialIntVal::_equalsValOverride(Val* val)
-{
-    if (auto genericParamVal = as<GenericParamIntVal>(val))
-    {
-        return constantTerm == 0 && terms.getCount() == 1 &&
-               terms[0]->paramFactors.getCount() == 1 && terms[0]->constFactor == 1 &&
-               terms[0]->paramFactors[0]->param->equalsVal(genericParamVal) &&
-               terms[0]->paramFactors[0]->power == 1;
-    }
-    else if (auto otherPolynomial = as<PolynomialIntVal>(val))
-    {
-        if (constantTerm != otherPolynomial->constantTerm)
-            return false;
-        if (terms.getCount() != otherPolynomial->terms.getCount())
-            return false;
-        for (Index i = 0; i < terms.getCount(); i++)
-        {
-            auto& thisTerm = *(terms[i]);
-            auto& thatTerm = *(otherPolynomial->terms[i]);
-            if (thisTerm.constFactor != thatTerm.constFactor)
-                return false;
-            if (thisTerm.paramFactors.getCount() != thatTerm.paramFactors.getCount())
-                return false;
-            for (Index j = 0; j < thisTerm.paramFactors.getCount(); j++)
-            {
-                if (thisTerm.paramFactors[j]->power != thatTerm.paramFactors[j]->power)
-                    return false;
-                if (!thisTerm.paramFactors[j]->param->equalsVal(thatTerm.paramFactors[j]->param))
-                    return false;
-            }
-        }
-        return true;
-    }
-    return false;
-}
-
 void PolynomialIntVal::_toTextOverride(StringBuilder& out)
 {
+    auto constantTerm = getConstantTerm();
+    auto terms = getTerms();
     for (Index i = 0; i < terms.getCount(); i++)
     {
         auto& term = *(terms[i]);
-        if (term.constFactor > 0)
+        if (term.getConstFactor() > 0)
         {
             if (i > 0)
                 out << "+";
@@ -784,14 +660,14 @@ void PolynomialIntVal::_toTextOverride(StringBuilder& out)
         else
             out << "-";
         bool isFirstFactor = true;
-        if (abs(term.constFactor) != 1 || term.paramFactors.getCount() == 0)
+        if (abs(term.getConstFactor()) != 1 || term.getParamFactors().getCount() == 0)
         {
-            out << abs(term.constFactor);
+            out << abs(term.getConstFactor());
             isFirstFactor = false;
         }
-        for (Index j = 0; j < term.paramFactors.getCount(); j++)
+        for (Index j = 0; j < term.getParamFactors().getCount(); j++)
         {
-            auto factor = term.paramFactors[j];
+            auto factor = term.getParamFactors()[j];
             if (isFirstFactor)
             {
                 isFirstFactor = false;
@@ -800,10 +676,10 @@ void PolynomialIntVal::_toTextOverride(StringBuilder& out)
             {
                 out << "*";
             }
-            factor->param->toText(out);
-            if (factor->power != 1)
+            factor->getParam()->toText(out);
+            if (factor->getPower() != 1)
             {
-                out << "^^" << factor->power;
+                out << "^^" << factor->getPower();
             }
         }
     }
@@ -821,227 +697,304 @@ void PolynomialIntVal::_toTextOverride(StringBuilder& out)
     }
 }
 
-HashCode PolynomialIntVal::_getHashCodeOverride()
+struct PolynomialIntValBuilder
 {
-    HashCode result = (HashCode)constantTerm;
-    for (auto& term : terms)
+    ASTBuilder* astBuilder;
+
+    IntegerLiteralValue constantTerm = 0;
+    List<PolynomialIntValTerm*> terms;
+
+    PolynomialIntValBuilder(ASTBuilder* inAstBuilder)
+        : astBuilder(inAstBuilder)
+    {}
+
+    // compute val += opreand*multiplier;
+    bool addToPolynomialTerm(IntVal* operand, IntegerLiteralValue multiplier)
     {
-        if (!term) continue;
-        result = combineHash(result, (HashCode)term->constFactor);
-        for (auto& factor : term->paramFactors)
+        if (auto c = as<ConstantIntVal>(operand))
         {
-            result = combineHash(result, factor->param->getHashCode());
-            result = combineHash(result, (HashCode)factor->power);
+            constantTerm += c->getValue() * multiplier;
+            return true;
         }
+        else if (auto poly = as<PolynomialIntVal>(operand))
+        {
+            constantTerm += poly->getConstantTerm() * multiplier;
+            for (auto term : poly->getTerms())
+            {
+                auto newTerm = astBuilder->getOrCreate<PolynomialIntValTerm>(
+                    multiplier * term->getConstFactor(), term->getParamFactors());
+                terms.add(newTerm);
+            }
+            return true;
+        }
+        else if (auto genVal = as<IntVal>(operand))
+        {
+            auto factor = astBuilder->getOrCreate<PolynomialIntValFactor>(genVal, 1);
+            auto term = astBuilder->getOrCreate<PolynomialIntValTerm>(multiplier, makeArrayViewSingle(factor));
+            terms.add(term);
+            return true;
+        }
+        return false;
     }
-    return result;
-}
+
+    IntVal* canonicalize(Type* type)
+    {
+        List<PolynomialIntValTerm*> newTerms;
+        IntegerLiteralValue newConstantTerm = constantTerm;
+        auto addTerm = [&](PolynomialIntValTerm* newTerm)
+        {
+            for (auto& term : newTerms)
+            {
+                if (term->canCombineWith(*newTerm))
+                {
+                    term = astBuilder->getOrCreate<PolynomialIntValTerm>(
+                        term->getConstFactor() + newTerm->getConstFactor(),
+                        term->getParamFactors());
+                    return;
+                }
+            }
+            newTerms.add(newTerm);
+        };
+        for (auto term : terms)
+        {
+            if (term->getConstFactor() == 0)
+                continue;
+            List<PolynomialIntValFactor*> newFactors;
+            List<bool> factorIsDifferent;
+            for (Index i = 0; i < term->getParamFactors().getCount(); i++)
+            {
+                auto factor = term->getParamFactors()[i];
+                bool factorFound = false;
+                for (Index j = 0; j < newFactors.getCount(); j++)
+                {
+                    auto& newFactor = newFactors[j];
+                    if (factor->getParam()->equals(newFactor->getParam()))
+                    {
+                        if (!factorIsDifferent[j])
+                        {
+                            factorIsDifferent[j] = true;
+                            auto clonedFactor = astBuilder->getOrCreate<PolynomialIntValFactor>(newFactor->getParam(), newFactor->getPower());
+                            newFactor = clonedFactor;
+                        }
+                        newFactor = astBuilder->getOrCreate<PolynomialIntValFactor>(newFactor->getParam(), newFactor->getPower() + factor->getPower());
+                        factorFound = true;
+                        break;
+                    }
+                }
+                if (!factorFound)
+                {
+                    newFactors.add(factor);
+                    factorIsDifferent.add(false);
+                }
+            }
+            List<PolynomialIntValFactor*> newFactors2;
+            // Remove zero-powered factors.
+            for (auto factor : newFactors)
+            {
+                if (factor->getPower() != 0)
+                    newFactors2.add(factor);
+            }
+            if (newFactors2.getCount() == 0)
+            {
+                newConstantTerm += term->getConstFactor();
+                continue;
+            }
+            newFactors2.sort([](PolynomialIntValFactor* t1, PolynomialIntValFactor* t2) {return *t1 < *t2; });
+            bool isDifferent = false;
+            if (newFactors2.getCount() != term->getParamFactors().getCount())
+                isDifferent = true;
+            if (!isDifferent)
+            {
+                for (Index i = 0; i < term->getParamFactors().getCount(); i++)
+                    if (term->getParamFactors()[i] != newFactors2[i])
+                    {
+                        isDifferent = true;
+                        break;
+                    }
+            }
+            if (!isDifferent)
+            {
+                addTerm(term);
+            }
+            else
+            {
+                auto newTerm = astBuilder->getOrCreate<PolynomialIntValTerm>(term->getConstFactor(), newFactors2.getArrayView());
+                addTerm(newTerm);
+            }
+        }
+        List<PolynomialIntValTerm*> newTerms2;
+        for (auto term : newTerms)
+        {
+            if (term->getConstFactor() == 0)
+                continue;
+            newTerms2.add(term);
+        }
+        newTerms2.sort([](PolynomialIntValTerm* t1, PolynomialIntValTerm* t2) {return *t1 < *t2; });
+        terms = _Move(newTerms2);
+        constantTerm = newConstantTerm;
+        if (terms.getCount() == 1 && constantTerm == 0 && terms[0]->getConstFactor() == 1 && terms[0]->getParamFactors().getCount() == 1 &&
+            terms[0]->getParamFactors()[0]->getPower() == 1)
+        {
+            return terms[0]->getParamFactors()[0]->getParam();
+        }
+        if (terms.getCount() == 0)
+            return astBuilder->getIntVal(type, constantTerm);
+        return nullptr;
+    }
+
+    IntVal* getIntVal(Type* type)
+    {
+        if (auto canVal = canonicalize(type))
+            return canVal;
+        return astBuilder->getOrCreate<PolynomialIntVal>(type, constantTerm, terms.getArrayView());
+    }
+};
 
 Val* PolynomialIntVal::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
-    IntegerLiteralValue evaluatedConstantTerm = constantTerm;
-    List<PolynomialIntValTerm*> evaluatedTerms;
-    for (auto& term : terms)
+    PolynomialIntValBuilder builder(astBuilder);
+    for (auto& term : getTerms())
     {
         IntegerLiteralValue evaluatedTermConstFactor;
         List<PolynomialIntValFactor*> evaluatedTermParamFactors;
-        evaluatedTermConstFactor = term->constFactor;
-        for (auto& factor : term->paramFactors)
+        evaluatedTermConstFactor = term->getConstFactor();
+        for (auto& factor : term->getParamFactors())
         {
-            auto substResult = factor->param->substituteImpl(astBuilder, subst, &diff);
+            auto substResult = factor->getParam()->substituteImpl(astBuilder, subst, &diff);
             
             if (auto constantVal = as<ConstantIntVal>(substResult))
             {
-                evaluatedTermConstFactor *= constantVal->value;
+                evaluatedTermConstFactor *= constantVal->getValue();
             }
             else if (auto intResult = as<IntVal>(substResult))
             {
-                auto newFactor = astBuilder->create<PolynomialIntValFactor>();
-                newFactor->param = intResult;
-                newFactor->power = factor->power;
+                auto newFactor = astBuilder->getOrCreate<PolynomialIntValFactor>(intResult, factor->getPower());
                 evaluatedTermParamFactors.add(newFactor);
             }
         }
         if (evaluatedTermParamFactors.getCount() == 0)
         {
-            evaluatedConstantTerm += evaluatedTermConstFactor;
+            builder.constantTerm += evaluatedTermConstFactor;
         }
         else
         {
-            auto newTerm = astBuilder->create<PolynomialIntValTerm>();
-            newTerm->paramFactors = _Move(evaluatedTermParamFactors);
-            newTerm->constFactor = evaluatedTermConstFactor;
-            evaluatedTerms.add(newTerm);
+            auto newTerm = astBuilder->getOrCreate<PolynomialIntValTerm>(
+                evaluatedTermConstFactor, evaluatedTermParamFactors.getArrayView());
+            builder.terms.add(newTerm);
         }
     }
 
     *ioDiff += diff;
 
-    if (evaluatedTerms.getCount() == 0)
-        return astBuilder->getIntVal(type, evaluatedConstantTerm);
+    if (builder.terms.getCount() == 0)
+        return astBuilder->getIntVal(getType(), builder.constantTerm);
     if (diff != 0)
     {
-        auto newPolynomial = astBuilder->create<PolynomialIntVal>(type);
-        newPolynomial->constantTerm = evaluatedConstantTerm;
-        newPolynomial->terms = _Move(evaluatedTerms);
-        return newPolynomial->canonicalize(astBuilder);
+        return builder.getIntVal(getType());
     }
     return this;
 }
 
-
-// compute val += opreand*multiplier;
-bool addToPolynomialTerm(ASTBuilder* astBuilder, PolynomialIntVal* val, IntVal* operand, IntegerLiteralValue multiplier)
-{
-    if (auto c = as<ConstantIntVal>(operand))
-    {
-        val->constantTerm += c->value * multiplier;
-        return true;
-    }
-    else if (auto poly = as<PolynomialIntVal>(operand))
-    {
-        val->constantTerm += poly->constantTerm * multiplier;
-        for (auto term : poly->terms)
-        {
-            auto newTerm = astBuilder->create<PolynomialIntValTerm>();
-            newTerm->constFactor = multiplier * term->constFactor;
-            newTerm->paramFactors = term->paramFactors;
-            val->terms.add(newTerm);
-        }
-        return true;
-    }
-    else if (auto genVal = as<IntVal>(operand))
-    {
-        auto term = astBuilder->create<PolynomialIntValTerm>();
-        term->constFactor = multiplier;
-        auto factor = astBuilder->create<PolynomialIntValFactor>();
-        factor->power = 1;
-        factor->param = genVal;
-        term->paramFactors.add(factor);
-        val->terms.add(term);
-        return true;
-    }
-    return false;
-}
-
-PolynomialIntVal* PolynomialIntVal::neg(ASTBuilder* astBuilder, IntVal* base)
+IntVal* PolynomialIntVal::neg(ASTBuilder* astBuilder, IntVal* base)
 {
-    auto result = astBuilder->create<PolynomialIntVal>(base->type);
-    if (!addToPolynomialTerm(astBuilder, result, base, -1))
-        return nullptr;
-    result->canonicalize(astBuilder);
-    return result;
+    PolynomialIntValBuilder builder(astBuilder);
+    builder.addToPolynomialTerm(base, -1);
+    return builder.getIntVal(base->getType());
 }
 
-PolynomialIntVal* PolynomialIntVal::sub(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1)
+IntVal* PolynomialIntVal::sub(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1)
 {
-    auto result = astBuilder->create<PolynomialIntVal>(op0->type);
-    if (!addToPolynomialTerm(astBuilder, result, op0, 1))
-        return nullptr;
-    if (!addToPolynomialTerm(astBuilder, result, op1, -1))
-        return nullptr;
-    result->canonicalize(astBuilder);
-    return result;
+    PolynomialIntValBuilder builder(astBuilder);
+    builder.addToPolynomialTerm(op0, 1);
+    builder.addToPolynomialTerm(op1, -1);
+    return builder.getIntVal(op0->getType());
 }
 
-PolynomialIntVal* PolynomialIntVal::add(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1)
+IntVal* PolynomialIntVal::add(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1)
 {
-    auto result = astBuilder->create<PolynomialIntVal>(op0->type);
-    if (!addToPolynomialTerm(astBuilder, result, op0, 1))
-        return nullptr;
-    if (!addToPolynomialTerm(astBuilder, result, op1, 1))
-        return nullptr;
-    result->canonicalize(astBuilder);
-    return result;
+    PolynomialIntValBuilder builder(astBuilder);
+    builder.addToPolynomialTerm(op0, 1);
+    builder.addToPolynomialTerm(op1, 1);
+    return builder.getIntVal(op0->getType());
 }
 
-PolynomialIntVal* PolynomialIntVal::mul(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1)
+IntVal* PolynomialIntVal::mul(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1)
 {
     if (auto poly0 = as<PolynomialIntVal>(op0))
     {
         if (auto poly1 = as<PolynomialIntVal>(op1))
         {
-            auto result = astBuilder->create<PolynomialIntVal>(poly0->type);
+            PolynomialIntValBuilder builder(astBuilder);
             // add poly0.constant * poly1.constant
-            result->constantTerm = poly0->constantTerm * poly1->constantTerm;
+            builder.constantTerm = poly0->getConstantTerm() * poly1->getConstantTerm();
             // add poly0.constant * poly1.terms
-            if (poly0->constantTerm != 0)
+            if (poly0->getConstantTerm() != 0)
             {
-                for (auto term : poly1->terms)
+                for (auto term : poly1->getTerms())
                 {
-                    auto newTerm = astBuilder->create<PolynomialIntValTerm>();
-                    newTerm->constFactor = poly0->constantTerm * term->constFactor;
-                    newTerm->paramFactors.addRange(term->paramFactors);
-                    result->terms.add(newTerm);
+                    auto newTerm = astBuilder->getOrCreate<PolynomialIntValTerm>(
+                        poly0->getConstantTerm() * term->getConstFactor(), term->getParamFactors());
+                    builder.terms.add(newTerm);
                 }
             }
             // add poly1.constant * poly0.terms
-            if (poly1->constantTerm != 0)
+            if (poly1->getConstantTerm() != 0)
             {
-                for (auto term : poly0->terms)
+                for (auto term : poly0->getTerms())
                 {
-                    auto newTerm = astBuilder->create<PolynomialIntValTerm>();
-                    newTerm->constFactor = poly1->constantTerm * term->constFactor;
-                    newTerm->paramFactors.addRange(term->paramFactors);
-                    result->terms.add(newTerm);
+                    auto newTerm = astBuilder->getOrCreate<PolynomialIntValTerm>(
+                        poly1->getConstantTerm() * term->getConstFactor(),
+                        term->getParamFactors());
+                    builder.terms.add(newTerm);
                 }
             }
             // add poly1.terms * poly0.terms
-            for (auto term0 : poly0->terms)
+            for (auto term0 : poly0->getTerms())
             {
-                for (auto term1 : poly1->terms)
+                for (auto term1 : poly1->getTerms())
                 {
-                    auto newTerm = astBuilder->create<PolynomialIntValTerm>();
-                    newTerm->constFactor = term0->constFactor * term1->constFactor;
-                    newTerm->paramFactors.addRange(term0->paramFactors);
-                    newTerm->paramFactors.addRange(term1->paramFactors);
-                    result->terms.add(newTerm);
+                    List<PolynomialIntValFactor*> newFactors;
+                    for (auto f : term0->getParamFactors()) newFactors.add(f);
+                    for (auto f : term1->getParamFactors()) newFactors.add(f);
+                    auto newTerm = astBuilder->getOrCreate<PolynomialIntValTerm>(
+                        term0->getConstFactor() * term1->getConstFactor(), newFactors.getArrayView());
+                    builder.terms.add(newTerm);
                 }
             }
-            result->canonicalize(astBuilder);
-            return result;
+            return builder.getIntVal(op0->getType());
         }
         else if (auto cVal1 = as<ConstantIntVal>(op1))
         {
-            auto result = astBuilder->create<PolynomialIntVal>(poly0->type);
-            result->constantTerm = poly0->constantTerm * cVal1->value;
-            auto factor1 = astBuilder->create<PolynomialIntValFactor>();
-            for (auto term : poly0->terms)
+            PolynomialIntValBuilder builder(astBuilder);
+            builder.constantTerm = poly0->getConstantTerm() * cVal1->getValue();
+            for (auto term : poly0->getTerms())
             {
-                auto newTerm = astBuilder->create<PolynomialIntValTerm>();
-                newTerm->constFactor = term->constFactor * cVal1->value;
-                newTerm->paramFactors.addRange(term->paramFactors);
-                newTerm->paramFactors.add(factor1);
-                result->terms.add(newTerm);
+                auto newTerm = astBuilder->getOrCreate<PolynomialIntValTerm>(term->getConstFactor() * cVal1->getValue(), term->getParamFactors());
+                builder.terms.add(newTerm);
             }
-            result->canonicalize(astBuilder);
-            return result;
+            return builder.getIntVal(poly0->getType());
         }
         else if (auto val1 = as<IntVal>(op1))
         {
-            auto result = astBuilder->create<PolynomialIntVal>(poly0->type);
-            result->constantTerm = 0;
-            auto factor1 = astBuilder->create<PolynomialIntValFactor>();
-            factor1->power = 1;
-            factor1->param = val1;
-            if (poly0->constantTerm != 0)
+            PolynomialIntValBuilder builder(astBuilder);
+            auto factor1 = astBuilder->getOrCreate<PolynomialIntValFactor>(val1, 1);
+            if (poly0->getConstantTerm() != 0)
             {
-                auto term0 = astBuilder->create<PolynomialIntValTerm>();
-                term0->constFactor = poly0->constantTerm;
-                term0->paramFactors.add(factor1);
-                result->terms.add(term0);
+                auto term0 = astBuilder->getOrCreate<PolynomialIntValTerm>(poly0->getConstantTerm(), makeArrayViewSingle(factor1));
+                builder.terms.add(term0);
             }
-            for (auto term : poly0->terms)
+            for (auto term : poly0->getTerms())
             {
-                auto newTerm = astBuilder->create<PolynomialIntValTerm>();
-                newTerm->constFactor = term->constFactor;
-                newTerm->paramFactors.addRange(term->paramFactors);
-                newTerm->paramFactors.add(factor1);
-                result->terms.add(newTerm);
+                List<PolynomialIntValFactor*> newFactors;
+                for (auto f: term->getParamFactors())
+                    newFactors.add(f);
+                newFactors.add(factor1);
+                auto newTerm = astBuilder->getOrCreate<PolynomialIntValTerm>(
+                    term->getConstFactor(), newFactors.getArrayView());
+                builder.terms.add(newTerm);
             }
-            result->canonicalize(astBuilder);
-            return result;
+            return builder.getIntVal(poly0->getType());
         }
         else
             return nullptr;
@@ -1058,184 +1011,48 @@ PolynomialIntVal* PolynomialIntVal::mul(ASTBuilder* astBuilder, IntVal* op0, Int
         }
         else if (auto cVal1 = as<ConstantIntVal>(op1))
         {
-            auto result = astBuilder->create<PolynomialIntVal>(val0->type);
-            auto term = astBuilder->create<PolynomialIntValTerm>();
-            term->constFactor = cVal1->value;
-            auto factor0 = astBuilder->create<PolynomialIntValFactor>();
-            factor0->power = 1;
-            factor0->param = val0;
-            term->paramFactors.add(factor0);
-            result->terms.add(term);
-            result->canonicalize(astBuilder);
-            return result;
+            PolynomialIntValBuilder builder(astBuilder);
+            auto factor0 = astBuilder->getOrCreate<PolynomialIntValFactor>(val0, 1);
+            auto term = astBuilder->getOrCreate<PolynomialIntValTerm>(
+                cVal1->getValue(), makeArrayView(&factor0, 1));
+            builder.terms.add(term);
+            return builder.getIntVal(val0->getType());
         }
         else if (auto val1 = as<IntVal>(op1))
         {
-            auto result = astBuilder->create<PolynomialIntVal>(val0->type);
-            auto term = astBuilder->create<PolynomialIntValTerm>();
-            term->constFactor = 1;
-            auto factor0 = astBuilder->create<PolynomialIntValFactor>();
-            factor0->power = 1;
-            factor0->param = val0;
-            term->paramFactors.add(factor0);
-            auto factor1 = astBuilder->create<PolynomialIntValFactor>();
-            factor1->power = 1;
-            factor1->param = val1;
-            term->paramFactors.add(factor1);
-            result->terms.add(term);
-            result->canonicalize(astBuilder);
-            return result;
+            PolynomialIntValBuilder builder(astBuilder);
+            auto factor0 = astBuilder->getOrCreate<PolynomialIntValFactor>(val0, 1);
+            auto factor1 = astBuilder->getOrCreate<PolynomialIntValFactor>(val1, 1);
+            PolynomialIntValFactor* newFactors[] = { factor0, factor1 };
+            auto term = astBuilder->getOrCreate<PolynomialIntValTerm>(1, makeArrayView(newFactors));
+            builder.terms.add(term);
+            return builder.getIntVal(val0->getType());
         }
     }
     return nullptr;
 }
 
-IntVal* PolynomialIntVal::canonicalize(ASTBuilder* builder)
-{
-    List<PolynomialIntValTerm*> newTerms;
-    IntegerLiteralValue newConstantTerm = constantTerm;
-    auto addTerm = [&](PolynomialIntValTerm* newTerm)
-    {
-        for (auto term : newTerms)
-        {
-            if (term->canCombineWith(*newTerm))
-            {
-                term->constFactor += newTerm->constFactor;
-                return;
-            }
-        }
-        newTerms.add(newTerm);
-    };
-    for (auto term : terms)
-    {
-        if (term->constFactor == 0)
-            continue;
-        List<PolynomialIntValFactor*> newFactors;
-        List<bool> factorIsDifferent;
-        for (Index i = 0; i < term->paramFactors.getCount(); i++)
-        {
-            auto factor = term->paramFactors[i];
-            bool factorFound = false;
-            for (Index j = 0; j < newFactors.getCount(); j++)
-            {
-                auto& newFactor = newFactors[j];
-                if (factor->param->equalsVal(newFactor->param))
-                {
-                    if (!factorIsDifferent[j])
-                    {
-                        factorIsDifferent[j] = true;
-                        auto clonedFactor = builder->create<PolynomialIntValFactor>();
-                        clonedFactor->param = newFactor->param;
-                        clonedFactor->power = newFactor->power;
-                        newFactor = clonedFactor;
-                    }
-                    newFactor->power += factor->power;
-                    factorFound = true;
-                    break;
-                }
-            }
-            if (!factorFound)
-            {
-                newFactors.add(factor);
-                factorIsDifferent.add(false);
-            }
-        }
-        List<PolynomialIntValFactor*> newFactors2;
-        for (auto factor : newFactors)
-        {
-            if (factor->power != 0)
-                newFactors2.add(factor);
-        }
-        if (newFactors2.getCount() == 0)
-        {
-            newConstantTerm += term->constFactor;
-            continue;
-        }
-        newFactors2.sort([](PolynomialIntValFactor* t1, PolynomialIntValFactor* t2) {return *t1 < *t2; });
-        bool isDifferent = false;
-        if (newFactors2.getCount() != term->paramFactors.getCount())
-            isDifferent = true;
-        if (!isDifferent)
-        {
-            for (Index i = 0; i < term->paramFactors.getCount(); i++)
-                if (term->paramFactors[i] != newFactors2[i])
-                {
-                    isDifferent = true;
-                    break;
-                }
-        }
-        if (!isDifferent)
-        {
-            addTerm(term);
-        }
-        else
-        {
-            auto newTerm = builder->create<PolynomialIntValTerm>();
-            newTerm->constFactor = term->constFactor;
-            newTerm->paramFactors = _Move(newFactors2);
-            addTerm(newTerm);
-        }
-    }
-    List<PolynomialIntValTerm*> newTerms2;
-    for (auto term : newTerms)
-    {
-        if (term->constFactor == 0)
-            continue;
-        newTerms2.add(term);
-    }
-    newTerms2.sort([](PolynomialIntValTerm* t1, PolynomialIntValTerm* t2) {return *t1 < *t2; });
-    terms = _Move(newTerms2);
-    constantTerm = newConstantTerm;
-    if (terms.getCount() == 1 && constantTerm == 0 && terms[0]->constFactor == 1 && terms[0]->paramFactors.getCount() == 1 &&
-        terms[0]->paramFactors[0]->power == 1)
-    {
-        return terms[0]->paramFactors[0]->param;
-    }
-    if (terms.getCount() == 0)
-        return builder->getIntVal(type, constantTerm);
-    return this;
-}
-
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! TypeCastIntVal !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-bool TypeCastIntVal::_equalsValOverride(Val* val)
-{
-    if (auto typeCastIntVal = as<TypeCastIntVal>(val))
-    {
-        if (!type->equals(typeCastIntVal->type))
-            return false;
-        if (!base->equalsVal(typeCastIntVal->base))
-            return false;
-        return true;
-    }
-    return false;
-}
 
 void TypeCastIntVal::_toTextOverride(StringBuilder& out)
 {
-    type->toText(out);
+    getType()->toText(out);
     out << "(";
-    base->toText(out);
+    getBase()->toText(out);
     out << ")";
 }
 
-HashCode TypeCastIntVal::_getHashCodeOverride()
-{
-    HashCode result = type->getHashCode();
-    result = combineHash(result, base->getHashCode());
-    return result;
-}
-
 Val* TypeCastIntVal::tryFoldImpl(ASTBuilder* astBuilder, Type* resultType, Val* base, DiagnosticSink* sink)
 {
     SLANG_UNUSED(sink);
 
     if (auto c = as<ConstantIntVal>(base))
     {
-        IntegerLiteralValue resultValue = c->value;
+        IntegerLiteralValue resultValue = c->getValue();
         auto baseType = as<BasicExpressionType>(resultType);
         if (baseType)
         {
-            switch (baseType->baseType)
+            switch (baseType->getBaseType())
             {
             case BaseType::Int:
                 resultValue = (int)resultValue;
@@ -1275,11 +1092,11 @@ Val* TypeCastIntVal::tryFoldImpl(ASTBuilder* astBuilder, Type* resultType, Val*
 Val* TypeCastIntVal::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
-    auto substBase = base->substituteImpl(astBuilder, subst, &diff);
-    if (substBase != base)
+    auto substBase = getBase()->substituteImpl(astBuilder, subst, &diff);
+    if (substBase != getBase())
         diff++;
-    auto substType = as<Type>(type->substituteImpl(astBuilder, subst, &diff));
-    if (substType != type)
+    auto substType = as<Type>(getType()->substituteImpl(astBuilder, subst, &diff));
+    if (substType != getType())
         diff++;
     *ioDiff += diff;
     if (diff)
@@ -1289,7 +1106,7 @@ Val* TypeCastIntVal::_substituteImplOverride(ASTBuilder* astBuilder, Substitutio
             return newVal;
         else
         {
-            auto result = astBuilder->create<TypeCastIntVal>(substType, substBase);
+            auto result = astBuilder->getOrCreate<TypeCastIntVal>(substType, substBase);
             return result;
         }
     }
@@ -1297,29 +1114,20 @@ Val* TypeCastIntVal::_substituteImplOverride(ASTBuilder* astBuilder, Substitutio
     return this;
 }
 
-
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! FuncCallIntVal !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-bool FuncCallIntVal::_equalsValOverride(Val* val)
+Val* TypeCastIntVal::_resolveImplOverride()
 {
-    if (auto funcCallIntVal = as<FuncCallIntVal>(val))
-    {
-        if (!funcDeclRef.equals(funcCallIntVal->funcDeclRef))
-            return false;
-        if (args.getCount() != funcCallIntVal->args.getCount())
-            return false;
-        for (Index i = 0; i < args.getCount(); i++)
-        {
-            if (!args[i]->equalsVal(funcCallIntVal->args[i]))
-                return false;
-        }
-        return true;
-    }
-    return false;
+    if (auto resolved = tryFoldImpl(getCurrentASTBuilder(), getType(), getBase(), nullptr))
+        return resolved;
+    return this;
 }
 
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! FuncCallIntVal !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
 void FuncCallIntVal::_toTextOverride(StringBuilder& out)
 {
+    auto args = getArgs();
+    auto funcDeclRef = getFuncDeclRef();
+
     auto argToText = [&](int index)
     {
         if (as<PolynomialIntVal>(args[index]) || as<FuncCallIntVal>(args[index]))
@@ -1369,14 +1177,37 @@ void FuncCallIntVal::_toTextOverride(StringBuilder& out)
     }
 }
 
-HashCode FuncCallIntVal::_getHashCodeOverride()
+Val* FuncCallIntVal::_resolveImplOverride()
 {
-    HashCode result = funcDeclRef.getHashCode();
+    auto astBuilder = getCurrentASTBuilder();
+    auto args = getArgs();
+    auto funcDeclRef = getFuncDeclRef();
+    auto funcType = getFuncType();
+
+    Val* resolvedVal = this;
+    
+    auto newFuncDeclRef = as<DeclRefBase>(funcDeclRef.declRefBase->resolve());
+    if (!newFuncDeclRef)
+        return this;
+    bool diff = false;
+    List<IntVal*> newArgs;
     for (auto arg : args)
     {
-        result = combineHash(result, arg->getHashCode());
+        auto newArg = as<IntVal>(arg->resolve());
+        if (!newArg)
+            return this;
+        newArgs.add(newArg);
+        if (newArg != arg)
+            diff = true;
     }
-    return result;
+
+    if (auto resolved = tryFoldImpl(astBuilder, getType(), newFuncDeclRef, newArgs, nullptr))
+        resolvedVal = resolved;
+    else if (diff)
+    {
+        resolvedVal = astBuilder->getOrCreate<FuncCallIntVal>(getType(), newFuncDeclRef, funcType, newArgs.getArrayView());
+    }
+    return resolvedVal;
 }
 
 Val* FuncCallIntVal::tryFoldImpl(ASTBuilder* astBuilder, Type* resultType, DeclRef<Decl> newFuncDecl, List<IntVal*>& newArgs, DiagnosticSink* sink)
@@ -1413,25 +1244,25 @@ Val* FuncCallIntVal::tryFoldImpl(ASTBuilder* astBuilder, Type* resultType, DeclR
 #define BINARY_OPERATOR_CASE(op) \
         if (opNameSlice == toSlice(#op)) \
         { \
-            resultValue = constArgs[0]->value op constArgs[1]->value; \
+            resultValue = constArgs[0]->getValue() op constArgs[1]->getValue(); \
         } else
 
 #define DIV_OPERATOR_CASE(op)                                                        \
         if (opNameSlice == toSlice(#op))                                             \
         {                                                                            \
-            if (constArgs[1]->value == 0)                                            \
+            if (constArgs[1]->getValue() == 0)                                            \
             {                                                                        \
                 if (sink)                                                            \
                     sink->diagnose(newFuncDecl.getLoc(), Diagnostics::divideByZero); \
                 return nullptr;                                                      \
             }                                                                        \
-            resultValue = constArgs[0]->value op constArgs[1]->value;                \
+            resultValue = constArgs[0]->getValue() op constArgs[1]->getValue();                \
         } else
 
 #define LOGICAL_OPERATOR_CASE(op) \
         if (opNameSlice == toSlice(#op)) \
         { \
-            resultValue = (((constArgs[0]->value!=0) op (constArgs[1]->value!=0)) ? 1 : 0); \
+            resultValue = (((constArgs[0]->getValue()!=0) op (constArgs[1]->getValue()!=0)) ? 1 : 0); \
         } else
 
 
@@ -1463,9 +1294,9 @@ Val* FuncCallIntVal::tryFoldImpl(ASTBuilder* astBuilder, Type* resultType, DeclR
         LOGICAL_OPERATOR_CASE(&&)
         LOGICAL_OPERATOR_CASE(||)
         // Special cases need their "operator" names quoted.
-        SPECIAL_OPERATOR_CASE("!", resultValue = ((constArgs[0]->value != 0) ? 1 : 0);)
-        SPECIAL_OPERATOR_CASE("~", resultValue = ~constArgs[0]->value;)
-        SPECIAL_OPERATOR_CASE("?:", resultValue = constArgs[0]->value != 0 ? constArgs[1]->value : constArgs[2]->value;)
+        SPECIAL_OPERATOR_CASE("!", resultValue = ((constArgs[0]->getValue() != 0) ? 1 : 0);)
+        SPECIAL_OPERATOR_CASE("~", resultValue = ~constArgs[0]->getValue();)
+        SPECIAL_OPERATOR_CASE("?:", resultValue = constArgs[0]->getValue() != 0 ? constArgs[1]->getValue() : constArgs[2]->getValue();)
         TERMINATING_CASE(SLANG_UNREACHABLE("constant folding of FuncCallIntVal");)
 
         return astBuilder->getIntVal(resultType, resultValue);
@@ -1483,9 +1314,9 @@ Val* FuncCallIntVal::tryFoldImpl(ASTBuilder* astBuilder, Type* resultType, DeclR
 Val* FuncCallIntVal::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
-    auto newFuncDeclRef = funcDeclRef.substituteImpl(astBuilder, subst, &diff);
+    auto newFuncDeclRef = getFuncDeclRef().substituteImpl(astBuilder, subst, &diff);
     List<IntVal*> newArgs;
-    for (auto& arg : args)
+    for (auto& arg : getArgs())
     {
         auto substArg = arg->substituteImpl(astBuilder, subst, &diff);
         if (substArg != arg)
@@ -1496,15 +1327,12 @@ Val* FuncCallIntVal::_substituteImplOverride(ASTBuilder* astBuilder, Substitutio
     if (diff)
     {
         // TODO: report diagnostics back.
-        auto newVal = tryFoldImpl(astBuilder, type, newFuncDeclRef, newArgs, nullptr);
+        auto newVal = tryFoldImpl(astBuilder, getType(), newFuncDeclRef, newArgs, nullptr);
         if (newVal)
             return newVal;
         else
         {
-            auto result = astBuilder->create<FuncCallIntVal>(type);
-            result->args = _Move(newArgs);
-            result->funcDeclRef = newFuncDeclRef;
-            result->funcType = funcType;
+            auto result = astBuilder->getOrCreate<FuncCallIntVal>(getType(), newFuncDeclRef, getFuncType(), newArgs.getArrayView());
             return result;
         }
     }
@@ -1514,40 +1342,47 @@ Val* FuncCallIntVal::_substituteImplOverride(ASTBuilder* astBuilder, Substitutio
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! WitnessLookupIntVal !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-bool WitnessLookupIntVal::_equalsValOverride(Val* val)
-{
-    if (auto lookupIntVal = as<WitnessLookupIntVal>(val))
-    {
-        if (!witness->equalsVal(lookupIntVal->witness))
-            return false;
-        if (key != lookupIntVal->key)
-            return false;
-        return true;
-    }
-    return false;
-}
-
 void WitnessLookupIntVal::_toTextOverride(StringBuilder& out)
 {
-    witness->sub->toText(out);
+    getWitness()->getSub()->toText(out);
     out << ".";
-    out << (key->getName() ? key->getName()->text : "??");
+    out << (getKey()->getName() ? getKey()->getName()->text : "??");
 }
 
-HashCode WitnessLookupIntVal::_getHashCodeOverride()
+Val* WitnessLookupIntVal::_resolveImplOverride()
 {
-    HashCode result = witness->getHashCode();
-    result = combineHash(result, Slang::getHashCode(key));
-    return result;
+    auto astBuilder = getCurrentASTBuilder();
+
+    auto newWitness = as<SubtypeWitness>(getWitness()->resolve());
+    if (!newWitness)
+        return this;
+
+    auto witnessVal = tryLookUpRequirementWitness(astBuilder, newWitness, getKey());
+    if (witnessVal.getFlavor() == RequirementWitness::Flavor::val)
+    {
+        return witnessVal.getVal();
+    }
+
+    auto newType = as<Type>(getType()->resolve());
+    if (!newType)
+        return this;
+
+    if (newWitness != getWitness() || newType != getType())
+    {
+        return astBuilder->getOrCreate<WitnessLookupIntVal>(newType, newWitness, getKey());
+    }
+
+    return this;
 }
+
 Val* WitnessLookupIntVal::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
-    auto newWitness = witness->substituteImpl(astBuilder, subst, &diff);
+    auto newWitness = getWitness()->substituteImpl(astBuilder, subst, &diff);
     *ioDiff += diff;
     if (diff)
     {
-        auto witnessEntry = tryFoldOrNull(astBuilder, as<SubtypeWitness>(newWitness), key);
+        auto witnessEntry = tryFoldOrNull(astBuilder, as<SubtypeWitness>(newWitness), getKey());
         if (witnessEntry)
             return witnessEntry;
     }
@@ -1573,51 +1408,93 @@ Val* WitnessLookupIntVal::tryFold(ASTBuilder* astBuilder, SubtypeWitness* witnes
 {
     if (auto result = tryFoldOrNull(astBuilder, witness, key))
         return result;
-    auto witnessResult = astBuilder->create<WitnessLookupIntVal>();
-    witnessResult->witness = witness;
-    witnessResult->key = key;
-    witnessResult->type = type;
+    auto witnessResult = astBuilder->getOrCreate<WitnessLookupIntVal>(type, witness, key);
     return witnessResult;
 }
 
-
-bool DifferentiateVal::_equalsValOverride(Val* val)
-{
-    if (auto other = as<DifferentiateVal>(val))
-    {
-        return other->astNodeType == astNodeType && other->func == func;
-    }
-    return false;
-}
-
 void DifferentiateVal::_toTextOverride(StringBuilder& out)
 {
     out << "DifferentiateVal(";
-    out << func;
+    out << getFunc();
     out << ")";
 }
 
-HashCode DifferentiateVal::_getHashCodeOverride()
-{
-    HashCode result = (HashCode)astNodeType;
-    result = combineHash(result, func.getHashCode());
-    return result;
-}
-
 Val* DifferentiateVal::_substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff)
 {
     int diff = 0;
-    auto newFunc = func.substituteImpl(astBuilder, subst, &diff);
+    auto newFunc = getFunc().substituteImpl(astBuilder, subst, &diff);
     *ioDiff += diff;
     if (diff)
     {
         auto result = as<DifferentiateVal>(astBuilder->createByNodeType(astNodeType));
-        result->func = newFunc;
+        result->getFunc() = newFunc;
         return result;
     }
     // Nothing found: don't substitute.
     return this;
 }
 
+Val* DifferentiateVal::_resolveImplOverride()
+{
+    return this;
+}
+
+Val* PolynomialIntValFactor::_resolveImplOverride()
+{
+    auto astBuilder = getCurrentASTBuilder();
+
+    auto newParam = as<IntVal>(getParam()->resolve());
+    if (newParam && newParam != getParam())
+        return astBuilder->getOrCreate<PolynomialIntValFactor>(newParam, getPower());
+
+    return this;
+}
+
+Val* PolynomialIntValTerm::_resolveImplOverride()
+{
+    auto astBuilder = getCurrentASTBuilder();
+
+    bool diff = false;
+    List<PolynomialIntValFactor*> newFactors;
+    for (auto factor : getParamFactors())
+    {
+        auto newFactor = as<PolynomialIntValFactor>(factor->resolve());
+        if (!newFactor)
+            return this;
+
+        if (newFactor != factor)
+            diff = true;
+        newFactors.add(newFactor);
+    }
+
+    if (diff)
+        return astBuilder->getOrCreate<PolynomialIntValTerm>(getConstFactor(), newFactors.getArrayView());
+
+    return this;
+}
+
+Val* PolynomialIntVal::_resolveImplOverride()
+{
+    auto astBuilder = getCurrentASTBuilder();
+
+    bool diff = false;
+    PolynomialIntValBuilder builder(astBuilder);
+    builder.constantTerm = getConstantTerm();
+    for (auto term : getTerms())
+    {
+        auto newTerm = as<PolynomialIntValTerm>(term->resolve());
+        if (!newTerm)
+            return this;
+
+        if (newTerm != term)
+            diff = true;
+        builder.terms.add(newTerm);
+    }
+
+    if (diff)
+        return builder.getIntVal(getType());
+
+    return this;
+}
 
 } // namespace Slang
diff --git a/source/slang/slang-ast-val.h b/source/slang/slang-ast-val.h
index cb4e94ebb..c45c42e02 100644
--- a/source/slang/slang-ast-val.h
+++ b/source/slang/slang-ast-val.h
@@ -8,17 +8,139 @@ namespace Slang {
 
 // Syntax class definitions for compile-time values.
 
+class DirectDeclRef : public DeclRefBase
+{
+public:
+    SLANG_AST_CLASS(DirectDeclRef)
+
+    DirectDeclRef(Decl* decl)
+    {
+        setOperands(decl);
+    }
+
+    DeclRefBase* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    void _toTextOverride(StringBuilder& out);
+    Val* _resolveImplOverride();
+    DeclRefBase* _getBaseOverride();
+};
+
+// Represent an static member of a base decl.
+// Note that we automatically fold the DeclRef if the path is known to be static.
+// For example, MemberDeclRef(DirectDeclRef(A), B) ==> DirectDeclRef(B),
+// and MemberDeclRef(MemberDeclRef(A, B), C) ==> MemberDeclRef(A, C).
+//
+class MemberDeclRef : public DeclRefBase
+{
+public:
+    SLANG_AST_CLASS(MemberDeclRef);
+
+    DeclRefBase* getParentOperand() { return as<DeclRefBase>(getOperand(1)); }
+
+    MemberDeclRef(Decl* decl, DeclRefBase* parent)
+    {
+        setOperands(decl, parent);
+    }
+
+    DeclRefBase* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+
+    void _toTextOverride(StringBuilder& out);
+
+    Val* _resolveImplOverride();
+
+    DeclRefBase* _getBaseOverride();
+};
+
+
+// Represent a lookup of SuperType::`m_decl` from `lookupSourceType` type that we know conforms to SuperType.
+class LookupDeclRef : public DeclRefBase
+{
+public:
+    SLANG_AST_CLASS(LookupDeclRef);
+
+    // m_decl represents the decl in SuperType that we want to lookup.
+
+    // The source type that we are looking up from.
+    Type* getLookupSource()
+    {
+        return as<Type>(getOperand(1));
+    }
+
+    // Witness that `lookupSourceType`:SuperType.
+    SubtypeWitness* getWitness()
+    {
+        return as<SubtypeWitness>(getOperand(2));
+    }
+
+    LookupDeclRef(Decl* declToLookup, Type* lookupSource, SubtypeWitness* witness)
+    {
+        setOperands(declToLookup, lookupSource, witness);
+    }
+
+    Decl* getSupDecl();
+
+    DeclRefBase* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+
+    void _toTextOverride(StringBuilder& out);
+
+    Val* _resolveImplOverride();
+
+    DeclRefBase* _getBaseOverride();
+
+private:
+    Val* tryResolve(SubtypeWitness* newWitness, Type* newLookupSource);
+};
+
+// Represents a specialization of a generic decl.
+class GenericAppDeclRef : public DeclRefBase
+{
+public:
+    SLANG_AST_CLASS(GenericAppDeclRef);
+
+    DeclRefBase* getGenericDeclRef() { return as<DeclRefBase>(getOperand(1)); }
+    Index getArgCount() { return getOperandCount() - 2; }
+    Val* getArg(Index index) { return getOperand(index + 2); }
+
+    GenericAppDeclRef(Decl* innerDecl, DeclRefBase* genericDeclRef, OperandView<Val> args)
+    {
+        m_operands.add(ValNodeOperand(innerDecl));
+        m_operands.add(ValNodeOperand(genericDeclRef));
+        for (auto arg : args)
+        {
+            m_operands.add(ValNodeOperand(arg));
+        }
+    }
+
+    GenericAppDeclRef(Decl* innerDecl, DeclRefBase* genericDeclRef, ConstArrayView<Val*> args)
+    {
+        m_operands.add(ValNodeOperand(innerDecl));
+        m_operands.add(ValNodeOperand(genericDeclRef));
+        for (auto arg : args)
+        {
+            m_operands.add(ValNodeOperand(arg));
+        }
+    }
+
+    GenericDecl* getGenericDecl();
+
+    OperandView<Val> getArgs() { return OperandView<Val>(this, 2, getArgCount()); }
+
+    DeclRefBase* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+
+    void _toTextOverride(StringBuilder& out);
+
+    Val* _resolveImplOverride();
+
+    DeclRefBase* _getBaseOverride();
+};
+
 // A compile-time integer (may not have a specific concrete value)
 class IntVal : public Val 
 {
     SLANG_ABSTRACT_AST_CLASS(IntVal)
 
-    Type* type;
-
-    IntVal(Type* inType)
-        : type(inType)
-    {}
+    Type* getType() { return as<Type>(getOperand(0)); }
 
+    Val* _resolveImplOverride() { return this; }
 };
 
 // Trivial case of a value that is just a constant integer
@@ -26,18 +148,15 @@ class ConstantIntVal : public IntVal
 {
     SLANG_AST_CLASS(ConstantIntVal)
 
-    IntegerLiteralValue value;
+    IntegerLiteralValue getValue() { return getIntConstOperand(1); }
 
     // Overrides should be public so base classes can access
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
 
-protected:
     ConstantIntVal(Type* inType, IntegerLiteralValue inValue)
-        : IntVal(inType), value(inValue)
-    {}
-
+    {
+        setOperands(inType, inValue);
+    }
 };
 
 // The logical "value" of a reference to a generic value parameter
@@ -45,30 +164,31 @@ class GenericParamIntVal : public IntVal
 {
     SLANG_AST_CLASS(GenericParamIntVal)
 
-    DeclRef<VarDeclBase> declRef;
+    DeclRef<VarDeclBase> getDeclRef() { return as<DeclRefBase>(getOperand(1)); }
 
     // Overrides should be public so base classes can access
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 
     GenericParamIntVal(Type* inType, DeclRef<VarDeclBase> inDeclRef)
-        : IntVal(inType), declRef(inDeclRef)
-    {}
+    {
+        setOperands(inType, inDeclRef);
+    }
 };
 
 class TypeCastIntVal : public IntVal
 {
     SLANG_AST_CLASS(TypeCastIntVal)
 
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* _resolveImplOverride();
 
-    Val* base;
-    TypeCastIntVal(Type* inType, Val* inBase) : IntVal(inType), base(inBase) {}
+    Val* getBase() { return getOperand(1); }
+    TypeCastIntVal(Type* inType, Val* inBase)
+    {
+        setOperands(inType, inBase);
+    }
 
     static Val* tryFoldImpl(ASTBuilder* astBuilder, Type* resultType, Val* base, DiagnosticSink* sink);
 };
@@ -78,16 +198,21 @@ class FuncCallIntVal : public IntVal
 {
     SLANG_AST_CLASS(FuncCallIntVal)
 
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* _resolveImplOverride();
 
-    DeclRef<Decl> funcDeclRef;
-    Type* funcType;
-    List<IntVal*> args;
+    DeclRef<Decl> getFuncDeclRef() { return as<DeclRefBase>(getOperand(1)); }
+    Type* getFuncType() { return as<Type>(getOperand(2)); }
+    OperandView<IntVal> getArgs() { return OperandView<IntVal>(this, 3, getOperandCount() - 3); }
+    Index getArgCount() { return getOperandCount() - 3; }
 
-    FuncCallIntVal(Type* inType) : IntVal(inType) {}
+    FuncCallIntVal(Type* inType, DeclRef<Decl> inFuncDeclRef, Type* inFuncType, ArrayView<IntVal*> inArgs)
+    {
+        setOperands(inType, inFuncDeclRef, inFuncType);
+        for (auto arg : inArgs)
+            m_operands.add(ValNodeOperand(arg));
+    }
 
     static Val* tryFoldImpl(ASTBuilder* astBuilder, Type* resultType, DeclRef<Decl> newFuncDecl, List<IntVal*>& newArgs, DiagnosticSink* sink);
 };
@@ -96,15 +221,17 @@ class WitnessLookupIntVal : public IntVal
 {
     SLANG_AST_CLASS(WitnessLookupIntVal)
 
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* _resolveImplOverride();
 
-    SubtypeWitness* witness;
-    Decl* key;
+    SubtypeWitness* getWitness() { return as<SubtypeWitness>(getOperand(1)); }
+    Decl* getKey() { return as<Decl>(getDeclOperand(2)); }
 
-    WitnessLookupIntVal(Type* inType) : IntVal(inType) {}
+    WitnessLookupIntVal(Type* inType, SubtypeWitness* witness, Decl* key)
+    {
+        setOperands(inType, witness, key);
+    }
 
     static Val* tryFoldOrNull(ASTBuilder* astBuilder, SubtypeWitness* witness, Decl* key);
 
@@ -113,23 +240,31 @@ class WitnessLookupIntVal : public IntVal
 
 // polynomial expression "2*a*b^3 + 1" will be represented as:
 // { constantTerm:1, terms: [ { constFactor:2, paramFactors:[{"a", 1}, {"b", 3}] } ] }
-class PolynomialIntValFactor : public NodeBase
+class PolynomialIntValFactor : public Val
 {
     SLANG_AST_CLASS(PolynomialIntValFactor)
 public:
-    IntVal* param;
-    IntegerLiteralValue power;
+    IntVal* getParam() const { return as<IntVal>(getOperand(0)); }
+    IntegerLiteralValue getPower() const { return getIntConstOperand(1); }
+
+    PolynomialIntValFactor(IntVal* inParam, IntegerLiteralValue inPower)
+    {
+        setOperands(inParam, inPower);
+    }
+
+    Val* _resolveImplOverride();
+
     // for sorting only.
     bool operator<(const PolynomialIntValFactor& other) const
     {
-        if (auto thisGenParam = as<GenericParamIntVal>(param))
+        if (auto thisGenParam = as<GenericParamIntVal>(getParam()))
         {
-            if (auto thatGenParam = as<GenericParamIntVal>(other.param))
+            if (auto thatGenParam = as<GenericParamIntVal>(other.getParam()))
             {
-                if (thisGenParam->equalsVal(thatGenParam))
-                    return power < other.power;
+                if (thisGenParam->equals(thatGenParam))
+                    return getPower() < other.getPower();
                 else
-                    return thisGenParam->declRef.getDecl() < thatGenParam->declRef.getDecl();
+                    return thisGenParam->getDeclRef().getDecl() < thatGenParam->getDeclRef().getDecl();
             }
             else
             {
@@ -138,64 +273,84 @@ public:
         }
         else
         {
-            if (const auto thatGenParam = as<GenericParamIntVal>(other.param))
+            if (const auto thatGenParam = as<GenericParamIntVal>(other.getParam()))
             {
                 return false;
             }
-            return param == other.param ? power < other.power : param < other.param;
+            return getParam() == other.getParam() ? getPower() < other.getPower() : getParam() < other.getParam();
         }
         
     }
     // for sorting only.
     bool operator==(const PolynomialIntValFactor& other) const
     {
-        if (auto thisGenParam = as<GenericParamIntVal>(param))
+        if (auto thisGenParam = as<GenericParamIntVal>(getParam()))
         {
-            if (auto thatGenParam = as<GenericParamIntVal>(other.param))
+            if (auto thatGenParam = as<GenericParamIntVal>(other.getParam()))
             {
-                if (thisGenParam->equalsVal(thatGenParam) && power == other.power)
+                if (thisGenParam->equals(thatGenParam) && getPower() == other.getPower())
                     return true;
             }
             return false;
         }
-        return power == other.power && param == other.param;
+        return getPower() == other.getPower() && getParam() == other.getParam();
     }
     bool equals(const PolynomialIntValFactor& other) const
     {
-        return power == other.power && param->equalsVal(other.param);
+        return getPower() == other.getPower() && getParam()->equals(other.getParam());
     }
 
 };
-class PolynomialIntValTerm : public NodeBase
+class PolynomialIntValTerm : public Val
 {
     SLANG_AST_CLASS(PolynomialIntValTerm)
 public:
-    IntegerLiteralValue constFactor;
-    List<PolynomialIntValFactor*> paramFactors;
+    IntegerLiteralValue getConstFactor() const { return getIntConstOperand(0); }
+    OperandView<PolynomialIntValFactor> getParamFactors() const { return OperandView<PolynomialIntValFactor>(this, 1, getOperandCount() - 1); }
+
+    Val* _resolveImplOverride();
+
+    PolynomialIntValTerm(IntegerLiteralValue inConstFactor, ArrayView<PolynomialIntValFactor*> inParamFactors)
+    {
+        setOperands(inConstFactor);
+        addOperands(inParamFactors);
+    }
+
+    PolynomialIntValTerm(IntegerLiteralValue inConstFactor, OperandView<PolynomialIntValFactor> inParamFactors)
+    {
+        setOperands(inConstFactor);
+        addOperands(inParamFactors);
+    }
+
     bool canCombineWith(const PolynomialIntValTerm& other) const
     {
-        if (paramFactors.getCount() != other.paramFactors.getCount())
+        auto paramFactors = getParamFactors();
+        if (paramFactors.getCount() != other.getParamFactors().getCount())
             return false;
-        for (Index i = 0; i < paramFactors.getCount(); i++)
+        for (Index i = 0; i < getParamFactors().getCount(); i++)
         {
-            if (!paramFactors[i]->equals(*other.paramFactors[i]))
+            if (!paramFactors[i]->equals(*other.getParamFactors()[i]))
                 return false;
         }
         return true;
     }
     bool operator<(const PolynomialIntValTerm& other) const
     {
-        if (constFactor < other.constFactor)
+        auto constFactor = getConstFactor();
+        auto paramFactors = getParamFactors();
+
+        if (constFactor < other.getConstFactor())
             return true;
-        else if (constFactor == other.constFactor)
+        else if (constFactor == other.getConstFactor())
         {
+            auto otherParamFactors = other.getParamFactors();
             for (Index i = 0; i < paramFactors.getCount(); i++)
             {
-                if (i >= other.paramFactors.getCount())
+                if (i >= otherParamFactors.getCount())
                     return false;
-                if (*(paramFactors[i]) < *(other.paramFactors[i]))
+                if (*(paramFactors[i]) < *(otherParamFactors[i]))
                     return true;
-                if (*(paramFactors[i]) == *(other.paramFactors[i]))
+                if (*(paramFactors[i]) == *(otherParamFactors[i]))
                 {
                 }
                 else
@@ -213,27 +368,25 @@ class PolynomialIntVal : public IntVal
     SLANG_AST_CLASS(PolynomialIntVal)
 public:
     
-    List<PolynomialIntValTerm*> terms;
-    IntegerLiteralValue constantTerm = 0;
+    IntegerLiteralValue getConstantTerm() { return getIntConstOperand(1); };
+    OperandView<PolynomialIntValTerm> getTerms() { return OperandView<PolynomialIntValTerm>(this, 2, getOperandCount() - 2); };
 
-    bool isConstant() { return terms.getCount() == 0; }
-    // Canonicalize the polynomial. If the polynomial can be simplified to a constant or a genericparam,
-    // the method returns the value simplified to.
-    // Otherwise, in-place modifications are performed and returns this.
-    IntVal* canonicalize(ASTBuilder* builder);
+    bool isConstant() { return getOperandCount() == 1; }
 
     // Overrides should be public so base classes can access
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* _resolveImplOverride();
 
-    static PolynomialIntVal* neg(ASTBuilder* astBuilder, IntVal* base);
-    static PolynomialIntVal* add(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1);
-    static PolynomialIntVal* sub(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1);
-    static PolynomialIntVal* mul(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1);
-    PolynomialIntVal(Type* inType) : IntVal(inType) {}
-
+    static IntVal* neg(ASTBuilder* astBuilder, IntVal* base);
+    static IntVal* add(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1);
+    static IntVal* sub(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1);
+    static IntVal* mul(ASTBuilder* astBuilder, IntVal* op0, IntVal* op1);
+    PolynomialIntVal(Type* inType, IntegerLiteralValue inConstantTerm, ArrayView<PolynomialIntValTerm*> inTerms)
+    {
+        setOperands(inType, inConstantTerm);
+        addOperands(inTerms);
+    }
 };
 
     /// An unknown integer value indicating an erroneous sub-expression
@@ -241,17 +394,16 @@ class ErrorIntVal : public IntVal
 {
     SLANG_AST_CLASS(ErrorIntVal)
 
-    ErrorIntVal(Type* inType) : IntVal(inType) {}
+    ErrorIntVal(Type* inType) { setOperands(inType); }
 
     // TODO: We should probably eventually just have an `ErrorVal` here
     // and have all `Val`s that represent ordinary values hold their
     // `Type` so that we can have an `ErrorVal` of any type.
 
     // Overrides should be public so base classes can access
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* _resolveImplOverride() { return this;  }
 };
 
 // A witness to the fact that some proposition is true, encoded
@@ -301,25 +453,23 @@ class SubtypeWitness : public Witness
 {
     SLANG_ABSTRACT_AST_CLASS(SubtypeWitness)
 
-    Type* sub = nullptr;
-    Type* sup = nullptr;
+    Val* _resolveImplOverride();
+
+    Type* getSub() { return as<Type>(getOperand(0)); }
+    Type* getSup() { return as<Type>(getOperand(1)); }
 };
 
 class TypeEqualityWitness : public SubtypeWitness 
 {
     SLANG_AST_CLASS(TypeEqualityWitness)
 
-    TypeEqualityWitness(
-        Type* type)
+    TypeEqualityWitness(Type* subType, Type* supType)
     {
-        this->sub = type;
-        this->sup = type;
+        setOperands(subType, supType);
     }
 
     // Overrides should be public so base classes can access
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 };
 
@@ -329,19 +479,19 @@ class DeclaredSubtypeWitness : public SubtypeWitness
 {
     SLANG_AST_CLASS(DeclaredSubtypeWitness)
 
-    DeclRef<Decl> declRef;
+    DeclRef<Decl> getDeclRef()
+    {
+        return as<DeclRefBase>(getOperand(2));
+    }
 
     // Overrides should be public so base classes can access
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* _resolveImplOverride();
 
     DeclaredSubtypeWitness(Type* inSub, Type* inSup, DeclRef<Decl> inDeclRef)
-        : declRef(inDeclRef)
     {
-        sub = inSub;
-        sup = inSup;
+        setOperands(inSub, inSup, inDeclRef);
     }
 };
 
@@ -351,20 +501,25 @@ class TransitiveSubtypeWitness : public SubtypeWitness
     SLANG_AST_CLASS(TransitiveSubtypeWitness)
 
     // Witness that `sub : mid`
-    SubtypeWitness* subToMid = nullptr;
+    SubtypeWitness* getSubToMid()
+    {
+        return as<SubtypeWitness>(getOperand(2));
+    }
 
     // Witness that `mid : sup`
-    SubtypeWitness* midToSup = nullptr;
+    SubtypeWitness* getMidToSup()
+    {
+        return as<SubtypeWitness>(getOperand(3));
+    }
 
     // Overrides should be public so base classes can access
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 
-    TransitiveSubtypeWitness(SubtypeWitness* inSubToMid, SubtypeWitness* inMidToSup)
-        : subToMid(inSubToMid), midToSup(inMidToSup)
-    {}
+    TransitiveSubtypeWitness(Type* subType, Type* supType, SubtypeWitness* inSubToMid, SubtypeWitness* inMidToSup)
+    {
+        setOperands(subType, supType, inSubToMid, inMidToSup);
+    }
 };
 
 // A witness that `sub : sup` because `sub` was wrapped into
@@ -374,52 +529,27 @@ class ExtractExistentialSubtypeWitness : public SubtypeWitness
     SLANG_AST_CLASS(ExtractExistentialSubtypeWitness)
 
     // The declaration of the existential value that has been opened
-    DeclRef<VarDeclBase> declRef;
-
-    // Overrides should be public so base classes can access
-    bool _equalsValOverride(Val* val);
-    void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
-    Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
-};
-
-// A witness that `sub : sup`, because `sub` is a tagged union
-// of the form `A | B | C | ...` and each of `A : sup`,
-// `B : sup`, `C : sup`, etc.
-//
-class TaggedUnionSubtypeWitness : public SubtypeWitness 
-{
-    SLANG_AST_CLASS(TaggedUnionSubtypeWitness)
+    DeclRef<VarDeclBase> getDeclRef() { return as<DeclRefBase>(getOperand(2)); }
 
-    // Witnesses that each of the "case" types in the union
-    // is a subtype of `sup`.
-    //
-    List<SubtypeWitness*> caseWitnesses;
+    ExtractExistentialSubtypeWitness(Type* inSub, Type* inSup, DeclRef<Decl> inDeclRef)
+    {
+        setOperands(inSub, inSup, inDeclRef);
+    }
 
     // Overrides should be public so base classes can access
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 };
 
-    /// A witness of the fact that `ThisType(someInterface) : someInterface`
-class ThisTypeSubtypeWitness : public SubtypeWitness
-{
-    SLANG_AST_CLASS(ThisTypeSubtypeWitness)
-
-    ThisTypeSubtypeWitness(Type* subType, Type* supType)
-    {
-        sub = subType;
-        sup = supType;
-    }
-};
-
     /// A witness of the fact that a user provided "__Dynamic" type argument is a
     /// subtype to the existential type parameter.
 class DynamicSubtypeWitness : public SubtypeWitness
 {
     SLANG_AST_CLASS(DynamicSubtypeWitness)
+    DynamicSubtypeWitness(Type* inSub, Type* inSup)
+    {
+        setOperands(inSub, inSup);
+    }
 };
 
     /// A witness that `T : L & R` because `T : L` and `T : R`
@@ -431,23 +561,24 @@ class ConjunctionSubtypeWitness : public SubtypeWitness
     // an operation that takes two witness tables `leftWitness`
     // and `rightWitness`, and forms a pair/tuple of
     // `(leftWitness, rightWitness)`.
+    static const int kComponentCount = 2;
 
-    static const Count kComponentCount = 2;
-    SubtypeWitness* componentWitnesses[kComponentCount];
+    ConjunctionSubtypeWitness(Type* inSub, Type* inSup, SubtypeWitness* left, SubtypeWitness* right)
+    {
+        setOperands(inSub, inSup, left, right);
+    }
 
-    SubtypeWitness* getLeftWitness() const { return componentWitnesses[0]; }
-    SubtypeWitness* getRightWitness() const { return componentWitnesses[1]; }
+    SubtypeWitness* getLeftWitness() const { return as<SubtypeWitness>(getOperand(2)); }
+    SubtypeWitness* getRightWitness() const { return as<SubtypeWitness>(getOperand(3)); }
 
-    Count getComponentCount() const { return kComponentCount; }
+    Count getComponentCount() const { return 2; }
     SubtypeWitness* getComponentWitness(Index index) const
     {
         SLANG_ASSERT(index >= 0 && index < kComponentCount);
-        return componentWitnesses[index];
+        return as<SubtypeWitness>(getOperand(2 + index));
     }
 
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 };
 
@@ -461,19 +592,22 @@ class ExtractFromConjunctionSubtypeWitness : public SubtypeWitness
     // `(leftWtiness, rightWitness)` and extracts one of the
     // elements of it.
 
-        /// Witness that `T < L & R`
-    SubtypeWitness* conjunctionWitness;
+    /// Witness that `T < L & R`
+    SubtypeWitness* getConjunctionWitness() { return as<SubtypeWitness>(getOperand(2)); };
+
+    ExtractFromConjunctionSubtypeWitness(Type* inSub, Type* inSup, SubtypeWitness* witness, int index)
+    {
+        setOperands(inSub, inSup, witness, index);
+    }
 
         /// The zero-based index of the super-type we care about in the conjunction
         ///
         /// If `conjunctionWitness` is `T < L & R` then this index should be zero if
         /// we want to represent `T < L` and one if we want `T < R`.
         ///
-    int indexInConjunction;
+    int getIndexInConjunction() { return (int)getIntConstOperand(3); };
 
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 };
 
@@ -482,8 +616,7 @@ class ModifierVal : public Val
 {
     SLANG_AST_CLASS(ModifierVal)
 
-    bool _equalsValOverride(Val* val);
-    HashCode _getHashCodeOverride();
+    Val* _resolveImplOverride() { return this; }
 };
 
 class TypeModifierVal : public ModifierVal
@@ -525,37 +658,91 @@ class DifferentiateVal : public Val
 {
     SLANG_AST_CLASS(DifferentiateVal)
 
-    DeclRef<Decl> func;
+    DifferentiateVal(DeclRef<Decl> inFunc)
+    {
+        setOperands(inFunc);
+    }
+
+    DeclRef<Decl> getFunc() { return as<DeclRefBase>(getOperand(0)); }
 
-    bool _equalsValOverride(Val* val);
     void _toTextOverride(StringBuilder& out);
-    HashCode _getHashCodeOverride();
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* _resolveImplOverride();
 };
 
 class ForwardDifferentiateVal : public DifferentiateVal
 {
     SLANG_AST_CLASS(ForwardDifferentiateVal)
+    ForwardDifferentiateVal(DeclRef<Decl> inFunc)
+        : DifferentiateVal(inFunc)
+    {}
 };
 
 class BackwardDifferentiateVal : public DifferentiateVal
 {
     SLANG_AST_CLASS(BackwardDifferentiateVal)
+
+    BackwardDifferentiateVal(DeclRef<Decl> inFunc)
+        : DifferentiateVal(inFunc)
+    {}
 };
 
 class BackwardDifferentiateIntermediateTypeVal : public DifferentiateVal
 {
     SLANG_AST_CLASS(BackwardDifferentiateIntermediateTypeVal)
+
+    BackwardDifferentiateIntermediateTypeVal(DeclRef<Decl> inFunc)
+        : DifferentiateVal(inFunc)
+    {}
 };
 
 class BackwardDifferentiatePrimalVal : public DifferentiateVal
 {
     SLANG_AST_CLASS(BackwardDifferentiatePrimalVal)
+
+    BackwardDifferentiatePrimalVal(DeclRef<Decl> inFunc)
+        : DifferentiateVal(inFunc)
+    {}
 };
 
 class BackwardDifferentiatePropagateVal : public DifferentiateVal
 {
     SLANG_AST_CLASS(BackwardDifferentiatePropagateVal)
+
+    BackwardDifferentiatePropagateVal(DeclRef<Decl> inFunc)
+        : DifferentiateVal(inFunc)
+    {}
 };
 
+
+template<typename F>
+void SubstitutionSet::forEachGenericSubstitution(F func) const
+{
+    if (!declRef)
+        return;
+    for (auto subst = declRef; subst; subst = subst->getBase())
+    {
+        if (auto genSubst = as<GenericAppDeclRef>(subst))
+            func(genSubst->getGenericDecl(), genSubst->getArgs());
+    }
+}
+
+template<typename F>
+void SubstitutionSet::forEachSubstitutionArg(F func) const
+{
+    if (!declRef)
+        return;
+    for (auto subst = declRef; subst; subst = subst->getBase())
+    {
+        if (auto genSubst = as<GenericAppDeclRef>(subst))
+        {
+            for (auto arg : genSubst->getArgs())
+                func(arg);
+        }
+        else if (auto thisSubst = as<LookupDeclRef>(subst))
+        {
+            func(thisSubst->getWitness()->getSub());
+        }
+    }
+}
 } // namespace Slang
diff --git a/source/slang/slang-check-conformance.cpp b/source/slang/slang-check-conformance.cpp
index 1d19e01bf..4376b1135 100644
--- a/source/slang/slang-check-conformance.cpp
+++ b/source/slang/slang-check-conformance.cpp
@@ -54,7 +54,7 @@ namespace Slang
         Type* superType)
     {
         SubtypeWitness* result = nullptr;
-        if (getShared()->tryGetSubtypeWitness(subType, superType, result))
+        if (getShared()->tryGetSubtypeWitnessFromCache(subType, superType, result))
             return result;
         result = checkAndConstructSubtypeWitness(subType, superType);
         getShared()->cacheSubtypeWitness(subType, superType, result);
@@ -107,11 +107,11 @@ namespace Slang
         // First, make sure both sub type and super type decl are ready for lookup.
         if (auto subDeclRefType = as<DeclRefType>(subType))
         {
-            ensureDecl(subDeclRefType->declRef.getDecl(), DeclCheckState::ReadyForLookup);
+            ensureDecl(subDeclRefType->getDeclRef().getDecl(), DeclCheckState::ReadyForLookup);
         }
         if (auto superDeclRefType = as<DeclRefType>(subType))
         {
-            ensureDecl(superDeclRefType->declRef.getDecl(), DeclCheckState::ReadyForLookup);
+            ensureDecl(superDeclRefType->getDeclRef().getDecl(), DeclCheckState::ReadyForLookup);
         }
 
         // In the common case, we can use the pre-computed inheritance information for `subType`
@@ -173,13 +173,13 @@ namespace Slang
         DeclRef<Decl> superTypeDeclRef;
         if (auto superDeclRefType = as<DeclRefType>(superType))
         {
-            superTypeDeclRef = superDeclRefType->declRef;
+            superTypeDeclRef = superDeclRefType->getDeclRef();
         }
 
-        if (auto dynamicType = as<DynamicType>(subType))
+        if (as<DynamicType>(subType))
         {
             // A __Dynamic type always conforms to the interface via its witness table.
-            auto witness = m_astBuilder->create<DynamicSubtypeWitness>();
+            auto witness = m_astBuilder->getOrCreate<DynamicSubtypeWitness>(subType, superType);
             return witness;
         }
         else if (auto conjunctionSuperType = as<AndType>(superType))
@@ -189,10 +189,10 @@ namespace Slang
             // We therefore simply recursively test both `T <: L`
             // and `T <: R`.
             //
-            auto leftWitness = isSubtype(subType, conjunctionSuperType->left);
+            auto leftWitness = isSubtype(subType, conjunctionSuperType->getLeft());
             if (!leftWitness) return nullptr;
             //
-            auto rightWitness = isSubtype(subType, conjunctionSuperType->right);
+            auto rightWitness = isSubtype(subType, conjunctionSuperType->getRight());
             if (!rightWitness) return nullptr;
 
             // If both of the sub-relationships hold, we can construct
@@ -214,7 +214,7 @@ namespace Slang
             // TODO(tfoley): We could add support for `ExtractExistentialType` to
             // the inheritance linearization logic, and eliminate this case.
             //
-            auto interfaceDeclRef = extractExistentialType->originalInterfaceDeclRef;
+            auto interfaceDeclRef = extractExistentialType->getOriginalInterfaceDeclRef();
             if (interfaceDeclRef.equals(superTypeDeclRef))
             {
                 auto witness = extractExistentialType->getSubtypeWitness();
@@ -222,62 +222,6 @@ namespace Slang
             }
             return nullptr;
         }
-        //
-        // TODO(tfoley): We should probably just remove `TaggedUnionType`,
-        // since there is no useful code that relies on it any more.
-        //
-        else if(auto taggedUnionType = as<TaggedUnionType>(subType))
-        {
-            // A tagged union type conforms to an interface if all of
-            // the constituent types in the tagged union conform.
-            //
-            // We will iterate over the "case" types in the tagged
-            // union, and check if they conform to the interface.
-            // Along the way we will collect the conformance witness
-            // values for the case types.
-            //
-            List<SubtypeWitness*> caseWitnesses;
-            for(auto caseType : taggedUnionType->caseTypes)
-            {
-                auto caseWitness = isSubtype(caseType, superType);
-
-                if(!caseWitness)
-                {
-                    return nullptr;
-                }
-
-                caseWitnesses.add(caseWitness);
-            }
-
-            // We also need to validate the requirements on
-            // the interface to make sure that they are suitable for
-            // use with a tagged-union type.
-            //
-            // For example, if the interface includes a `static` method
-            // (which can therefore be called without a particular instance),
-            // then we wouldn't know what implementation of that method
-            // to use because there is no tag value to dispatch on.
-            //
-            // We will start out being conservative about what we accept
-            // here, just to keep things simple.
-            //
-            if( auto superInterfaceDeclRef = superTypeDeclRef.as<InterfaceDecl>() )
-            {
-                if(!isInterfaceSafeForTaggedUnion(superInterfaceDeclRef))
-                    return nullptr;
-            }
-
-            // If we reach this point then we have a concrete
-            // witness for each of the case types, and that is
-            // enough to build a witness for the tagged union.
-            //
-            TaggedUnionSubtypeWitness* taggedUnionWitness = m_astBuilder->create<TaggedUnionSubtypeWitness>();
-            taggedUnionWitness->sub = taggedUnionType;
-            taggedUnionWitness->sup = superType;
-            taggedUnionWitness->caseWitnesses.swapWith(caseWitnesses);
-
-            return taggedUnionWitness;
-        }
 
         // default is failure
         return nullptr;
@@ -287,7 +231,7 @@ namespace Slang
     {
         if (auto declRefType = as<DeclRefType>(type))
         {
-            if (auto interfaceDeclRef = declRefType->declRef.as<InterfaceDecl>())
+            if (auto interfaceDeclRef = declRefType->getDeclRef().as<InterfaceDecl>())
                 return true;
         }
         return false;
diff --git a/source/slang/slang-check-constraint.cpp b/source/slang/slang-check-constraint.cpp
index 22a92bf0a..b9d33a1c1 100644
--- a/source/slang/slang-check-constraint.cpp
+++ b/source/slang/slang-check-constraint.cpp
@@ -65,14 +65,14 @@ namespace Slang
         // That is, the join of a vector and a scalar type is
         // a vector type with a joined element type.
         auto joinElementType = TryJoinTypes(
-            vectorType->elementType,
+            vectorType->getElementType(),
             scalarType);
         if(!joinElementType)
             return nullptr;
 
         return createVectorType(
             joinElementType,
-            vectorType->elementCount);
+            vectorType->getElementCount());
     }
 
     Type* SemanticsVisitor::_tryJoinTypeWithInterface(
@@ -110,11 +110,11 @@ namespace Slang
             for(Int baseTypeFlavorIndex = 0; baseTypeFlavorIndex < Int(BaseType::CountOf); baseTypeFlavorIndex++)
             {
                 // Don't consider `type`, since we already know it doesn't work.
-                if(baseTypeFlavorIndex == Int(basicType->baseType))
+                if(baseTypeFlavorIndex == Int(basicType->getBaseType()))
                     continue;
 
                 // Look up the type in our session.
-                auto candidateType = type->getASTBuilder()->getBuiltinType(BaseType(baseTypeFlavorIndex));
+                auto candidateType = getCurrentASTBuilder()->getBuiltinType(BaseType(baseTypeFlavorIndex));
                 if(!candidateType)
                     continue;
 
@@ -186,8 +186,8 @@ namespace Slang
         {
             if (auto rightBasic = as<BasicExpressionType>(right))
             {
-                auto leftFlavor = leftBasic->baseType;
-                auto rightFlavor = rightBasic->baseType;
+                auto leftFlavor = leftBasic->getBaseType();
+                auto rightFlavor = rightBasic->getBaseType();
 
                 // TODO(tfoley): Need a special-case rule here that if
                 // either operand is of type `half`, then we promote
@@ -217,19 +217,19 @@ namespace Slang
             if(auto rightVector = as<VectorExpressionType>(right))
             {
                 // Check if the vector sizes match
-                if(!leftVector->elementCount->equalsVal(rightVector->elementCount))
+                if(!leftVector->getElementCount()->equals(rightVector->getElementCount()))
                     return nullptr;
 
                 // Try to join the element types
                 auto joinElementType = TryJoinTypes(
-                    leftVector->elementType,
-                    rightVector->elementType);
+                    leftVector->getElementType(),
+                    rightVector->getElementType());
                 if(!joinElementType)
                     return nullptr;
 
                 return createVectorType(
                     joinElementType,
-                    leftVector->elementCount);
+                    leftVector->getElementCount());
             }
 
             // We can also join a vector and a scalar
@@ -242,7 +242,7 @@ namespace Slang
         // HACK: trying to work trait types in here...
         if(auto leftDeclRefType = as<DeclRefType>(left))
         {
-            if( auto leftInterfaceRef = leftDeclRefType->declRef.as<InterfaceDecl>() )
+            if( auto leftInterfaceRef = leftDeclRefType->getDeclRef().as<InterfaceDecl>() )
             {
                 //
                 return _tryJoinTypeWithInterface(right, left);
@@ -250,7 +250,7 @@ namespace Slang
         }
         if(auto rightDeclRefType = as<DeclRefType>(right))
         {
-            if( auto rightInterfaceRef = rightDeclRefType->declRef.as<InterfaceDecl>() )
+            if( auto rightInterfaceRef = rightDeclRefType->getDeclRef().as<InterfaceDecl>() )
             {
                 //
                 return _tryJoinTypeWithInterface(left, right);
@@ -263,10 +263,10 @@ namespace Slang
         return nullptr;
     }
 
-    SubstitutionSet SemanticsVisitor::trySolveConstraintSystem(
+    DeclRef<Decl> SemanticsVisitor::trySolveConstraintSystem(
         ConstraintSystem*       system,
         DeclRef<GenericDecl>    genericDeclRef,
-        GenericSubstitution*    substWithKnownGenericArgs)
+        ArrayView<Val*>         knownGenericArgs)
     {
         // For now the "solver" is going to be ridiculously simplistic.
 
@@ -288,9 +288,8 @@ namespace Slang
         for( auto constraintDeclRef : getMembersOfType<GenericTypeConstraintDecl>(m_astBuilder, genericDeclRef) )
         {
             if(!TryUnifyTypes(*system, getSub(m_astBuilder, constraintDeclRef), getSup(m_astBuilder, constraintDeclRef)))
-                return SubstitutionSet();
+                return DeclRef<Decl>();
         }
-        SubstitutionSet resultSubst = genericDeclRef.getSubst();
 
         // Once have built up the full list of constraints we are trying to satisfy,
         // we will attempt to solve for each parameter in a way that satisfies all
@@ -310,10 +309,10 @@ namespace Slang
         // or not they are compatible with the constraints).
         //
         Count knownGenericArgCount = 0;
-        if (substWithKnownGenericArgs)
+        if (knownGenericArgs.getCount())
         {
-            knownGenericArgCount = substWithKnownGenericArgs->getArgs().getCount();
-            for (auto arg : substWithKnownGenericArgs->getArgs())
+            knownGenericArgCount = knownGenericArgs.getCount();
+            for (auto arg : knownGenericArgs)
             {
                 args.add(arg);
             }
@@ -364,7 +363,7 @@ namespace Slang
                         if (!joinType)
                         {
                             // failure!
-                            return SubstitutionSet();
+                            return DeclRef<Decl>();
                         }
                         type = joinType;
                     }
@@ -375,7 +374,7 @@ namespace Slang
                 if (!type)
                 {
                     // failure!
-                    return SubstitutionSet();
+                    return DeclRef<Decl>();
                 }
                 args.add(type);
             }
@@ -417,10 +416,10 @@ namespace Slang
                     }
                     else
                     {
-                        if(!val->equalsVal(cVal))
+                        if(!val->equals(cVal))
                         {
                             // failure!
-                            return SubstitutionSet();
+                            return DeclRef<Decl>();
                         }
                     }
 
@@ -430,7 +429,7 @@ namespace Slang
                 if (!val)
                 {
                     // failure!
-                    return SubstitutionSet();
+                    return DeclRef<Decl>();
                 }
                 args.add(val);
             }
@@ -456,14 +455,10 @@ namespace Slang
         // search for a conformance `Robin : ISidekick`, which involved
         // apply the substitutions we already know...
 
-        GenericSubstitution* solvedSubst = m_astBuilder->getOrCreateGenericSubstitution(
-            genericDeclRef.getSubst(), genericDeclRef.getDecl(), args.getArrayView());
-
         for( auto constraintDecl : genericDeclRef.getDecl()->getMembersOfType<GenericTypeConstraintDecl>() )
         {
-            DeclRef<GenericTypeConstraintDecl> constraintDeclRef = m_astBuilder->getSpecializedDeclRef(
-                constraintDecl,
-                solvedSubst);
+            DeclRef<GenericTypeConstraintDecl> constraintDeclRef = m_astBuilder->getGenericAppDeclRef(
+                genericDeclRef, args.getArrayView(), constraintDecl).as<GenericTypeConstraintDecl>();
 
             // Extract the (substituted) sub- and super-type from the constraint.
             auto sub = getSub(m_astBuilder, constraintDeclRef);
@@ -476,7 +471,7 @@ namespace Slang
                 // not provide an explicit type parameter to specialize a generic
                 // and the type parameter cannot be inferred from any arguments.
                 // In this case, we should fail the constraint check.
-                return SubstitutionSet();
+                return DeclRef<Decl>();
             }
 
             // Search for a witness that shows the constraint is satisfied.
@@ -492,7 +487,7 @@ namespace Slang
                 //
                 // TODO: Ideally we should print an error message in
                 // this case, to let the user know why things failed.
-                return SubstitutionSet();
+                return DeclRef<Decl>();
             }
 
             // TODO: We may need to mark some constrains in our constraint
@@ -505,13 +500,11 @@ namespace Slang
         {
             if (!c.satisfied)
             {
-                return SubstitutionSet();
+                return DeclRef<Decl>();
             }
         }
 
-        resultSubst = m_astBuilder->getOrCreateGenericSubstitution(
-            genericDeclRef.getSubst(), genericDeclRef.getDecl(), args);
-        return resultSubst;
+        return m_astBuilder->getGenericAppDeclRef(genericDeclRef, args.getArrayView());
     }
 
     bool SemanticsVisitor::TryUnifyVals(
@@ -533,7 +526,7 @@ namespace Slang
         {
             if (auto sndIntVal = as<ConstantIntVal>(snd))
             {
-                return fstIntVal->value == sndIntVal->value;
+                return fstIntVal->getValue() == sndIntVal->getValue();
             }
         }
 
@@ -541,23 +534,23 @@ namespace Slang
         if (auto fstInt = as<IntVal>(fst))
         {
             if (auto tc = as<TypeCastIntVal>(fstInt))
-                fstInt = as<IntVal>(tc->base);
+                fstInt = as<IntVal>(tc->getBase());
             if (auto sndInt = as<IntVal>(snd))
             {
                 if (auto tc = as<TypeCastIntVal>(sndInt))
-                    sndInt = as<IntVal>(tc->base);
+                    sndInt = as<IntVal>(tc->getBase());
                 auto fstParam = as<GenericParamIntVal>(fstInt);
                 auto sndParam = as<GenericParamIntVal>(sndInt);
 
                 bool okay = false;
                 if (fstParam)
                 {
-                    if(TryUnifyIntParam(constraints, fstParam->declRef, sndInt))
+                    if(TryUnifyIntParam(constraints, fstParam->getDeclRef(), sndInt))
                         okay = true;
                 }
                 if (sndParam)
                 {
-                    if(TryUnifyIntParam(constraints, sndParam->declRef, fstInt))
+                    if(TryUnifyIntParam(constraints, sndParam->getDeclRef(), fstInt))
                         okay = true;
                 }
                 return okay;
@@ -568,8 +561,8 @@ namespace Slang
         {
             if (auto sndWit = as<DeclaredSubtypeWitness>(snd))
             {
-                auto constraintDecl1 = fstWit->declRef.as<TypeConstraintDecl>();
-                auto constraintDecl2 = sndWit->declRef.as<TypeConstraintDecl>();
+                auto constraintDecl1 = fstWit->getDeclRef().as<TypeConstraintDecl>();
+                auto constraintDecl2 = sndWit->getDeclRef().as<TypeConstraintDecl>();
                 SLANG_ASSERT(constraintDecl1);
                 SLANG_ASSERT(constraintDecl2);
                 return TryUnifyTypes(constraints,
@@ -586,8 +579,8 @@ namespace Slang
             if (auto sndWit = as<SubtypeWitness>(snd))
             {
                 return TryUnifyTypes(constraints,
-                    fstWit->sup,
-                    sndWit->sup);
+                    fstWit->getSup(),
+                    sndWit->getSup());
             }
         }
 
@@ -597,35 +590,28 @@ namespace Slang
         //return false;
     }
 
-    bool SemanticsVisitor::tryUnifySubstitutions(
-        ConstraintSystem&       constraints,
-        Substitutions*   fst,
-        Substitutions*   snd)
+    bool SemanticsVisitor::tryUnifyDeclRef(
+        ConstraintSystem& constraints,
+        DeclRefBase* fst,
+        DeclRefBase* snd)
     {
-        // They must both be NULL or non-NULL
-        if (!fst || !snd)
-            return !fst && !snd;
-
-        if(auto fstGeneric = as<GenericSubstitution>(fst))
-        {
-            if(auto sndGeneric = as<GenericSubstitution>(snd))
-            {
-                return tryUnifyGenericSubstitutions(
-                    constraints,
-                    fstGeneric,
-                    sndGeneric);
-            }
-        }
-
-        // TODO: need to handle other cases here
-
-        return false;
+        if (fst == snd)
+            return true;
+        if (fst == nullptr || snd == nullptr)
+            return false;
+        auto fstGen = SubstitutionSet(fst).findGenericAppDeclRef();
+        auto sndGen = SubstitutionSet(snd).findGenericAppDeclRef();
+        if (fstGen == sndGen)
+            return true;
+        if (fstGen == nullptr || sndGen == nullptr)
+            return false;
+        return tryUnifyGenericAppDeclRef(constraints, fstGen, sndGen);
     }
 
-    bool SemanticsVisitor::tryUnifyGenericSubstitutions(
+    bool SemanticsVisitor::tryUnifyGenericAppDeclRef(
         ConstraintSystem&           constraints,
-        GenericSubstitution* fst,
-        GenericSubstitution* snd)
+        GenericAppDeclRef* fst,
+        GenericAppDeclRef* snd)
     {
         SLANG_ASSERT(fst);
         SLANG_ASSERT(snd);
@@ -649,7 +635,10 @@ namespace Slang
         }
 
         // Their "base" specializations must unify
-        if (!tryUnifySubstitutions(constraints, fstGen->getOuter(), sndGen->getOuter()))
+        auto fstBase = fst->getBase();
+        auto sndBase = snd->getBase();
+
+        if (!tryUnifyDeclRef(constraints, fstBase, sndBase))
         {
             okay = false;
         }
@@ -718,14 +707,14 @@ namespace Slang
     {
         if (auto fstDeclRefType = as<DeclRefType>(fst))
         {
-            auto fstDeclRef = fstDeclRefType->declRef;
+            auto fstDeclRef = fstDeclRefType->getDeclRef();
 
             if (auto typeParamDecl = as<GenericTypeParamDecl>(fstDeclRef.getDecl()))
                 return TryUnifyTypeParam(constraints, typeParamDecl, snd);
 
             if (auto sndDeclRefType = as<DeclRefType>(snd))
             {
-                auto sndDeclRef = sndDeclRefType->declRef;
+                auto sndDeclRef = sndDeclRefType->getDeclRef();
 
                 if (auto typeParamDecl = as<GenericTypeParamDecl>(sndDeclRef.getDecl()))
                     return TryUnifyTypeParam(constraints, typeParamDecl, fst);
@@ -735,10 +724,10 @@ namespace Slang
 
                 // next we need to unify the substitutions applied
                 // to each declaration reference.
-                if (!tryUnifySubstitutions(
+                if (!tryUnifyDeclRef(
                     constraints,
-                    fstDeclRef.getSubst(),
-                    sndDeclRef.getSubst()))
+                    fstDeclRef,
+                    sndDeclRef))
                 {
                     return false;
                 }
@@ -749,15 +738,15 @@ namespace Slang
         {
             if (auto sndFunType = as<FuncType>(snd))
             {
-                const Index numParams = fstFunType->paramTypes.getCount();
-                if(numParams != sndFunType->paramTypes.getCount())
+                const Index numParams = fstFunType->getParamCount();
+                if(numParams != sndFunType->getParamCount())
                     return false;
                 for(Index i = 0; i < numParams; ++i)
                 {
-                    if(!TryUnifyTypes(constraints, fstFunType->paramTypes[i], sndFunType->paramTypes[i]))
+                    if(!TryUnifyTypes(constraints, fstFunType->getParamType(i), sndFunType->getParamType(i)))
                         return false;
                 }
-                return TryUnifyTypes(constraints, fstFunType->resultType, sndFunType->resultType);
+                return TryUnifyTypes(constraints, fstFunType->getResultType(), sndFunType->getResultType());
             }
         }
 
@@ -779,13 +768,13 @@ namespace Slang
         //
         if (auto fstAndType = as<AndType>(fst))
         {
-            return TryUnifyTypes(constraints, fstAndType->left, snd)
-                && TryUnifyTypes(constraints, fstAndType->right, snd);
+            return TryUnifyTypes(constraints, fstAndType->getLeft(), snd)
+                && TryUnifyTypes(constraints, fstAndType->getRight(), snd);
         }
         else if (auto sndAndType = as<AndType>(snd))
         {
-            return TryUnifyTypes(constraints, fst, sndAndType->left)
-                || TryUnifyTypes(constraints, fst, sndAndType->right);
+            return TryUnifyTypes(constraints, fst, sndAndType->getLeft())
+                || TryUnifyTypes(constraints, fst, sndAndType->getRight());
         }
         else
             return false;
@@ -828,7 +817,7 @@ namespace Slang
 
         if (auto fstDeclRefType = as<DeclRefType>(fst))
         {
-            auto fstDeclRef = fstDeclRefType->declRef;
+            auto fstDeclRef = fstDeclRefType->getDeclRef();
 
             if (auto typeParamDecl = as<GenericTypeParamDecl>(fstDeclRef.getDecl()))
             {
@@ -839,7 +828,7 @@ namespace Slang
 
         if (auto sndDeclRefType = as<DeclRefType>(snd))
         {
-            auto sndDeclRef = sndDeclRefType->declRef;
+            auto sndDeclRef = sndDeclRefType->getDeclRef();
 
             if (auto typeParamDecl = as<GenericTypeParamDecl>(sndDeclRef.getDecl()))
             {
@@ -863,7 +852,7 @@ namespace Slang
             {
                 return TryUnifyTypes(
                     constraints,
-                    fstVectorType->elementType,
+                    fstVectorType->getElementType(),
                     sndScalarType);
             }
         }
@@ -875,7 +864,7 @@ namespace Slang
                 return TryUnifyTypes(
                     constraints,
                     fstScalarType,
-                    sndVectorType->elementType);
+                    sndVectorType->getElementType());
             }
         }
 
diff --git a/source/slang/slang-check-conversion.cpp b/source/slang/slang-check-conversion.cpp
index abe9f4817..d89808c3d 100644
--- a/source/slang/slang-check-conversion.cpp
+++ b/source/slang/slang-check-conversion.cpp
@@ -61,7 +61,7 @@ namespace Slang
 
         if(auto declRefType = as<DeclRefType>(type))
         {
-            if(as<StructDecl>(declRefType->declRef))
+            if(as<StructDecl>(declRefType->getDeclRef()))
                 return false;
         }
 
@@ -174,7 +174,7 @@ namespace Slang
         if(!baseDeclRefType)
             return nullptr;
 
-        auto baseDeclRef = baseDeclRefType->declRef;
+        auto baseDeclRef = baseDeclRefType->getDeclRef();
         auto baseStructDeclRef = baseDeclRef.as<StructDecl>();
         if(!baseStructDeclRef)
             return nullptr;
@@ -193,7 +193,7 @@ namespace Slang
         if (!baseDeclRefType)
             return DeclRef<StructDecl>();
 
-        auto baseDeclRef = baseDeclRefType->declRef;
+        auto baseDeclRef = baseDeclRefType->getDeclRef();
         auto baseStructDeclRef = baseDeclRef.as<StructDecl>();
         if (!baseStructDeclRef)
             return DeclRef<StructDecl>();
@@ -244,13 +244,13 @@ namespace Slang
         }
         else if (auto toVecType = as<VectorExpressionType>(toType))
         {
-            auto toElementCount = toVecType->elementCount;
-            auto toElementType = toVecType->elementType;
+            auto toElementCount = toVecType->getElementCount();
+            auto toElementType = toVecType->getElementType();
 
             UInt elementCount = 0;
             if (auto constElementCount = as<ConstantIntVal>(toElementCount))
             {
-                elementCount = (UInt) constElementCount->value;
+                elementCount = (UInt) constElementCount->getValue();
             }
             else
             {
@@ -299,7 +299,7 @@ namespace Slang
                 UInt elementCount = 0;
                 if (auto constElementCount = as<ConstantIntVal>(toElementCount))
                 {
-                    elementCount = (UInt) constElementCount->value;
+                    elementCount = (UInt) constElementCount->getValue();
                 }
                 else
                 {
@@ -388,7 +388,7 @@ namespace Slang
 
             if (auto constRowCount = as<ConstantIntVal>(toMatrixType->getRowCount()))
             {
-                rowCount = (UInt) constRowCount->value;
+                rowCount = (UInt) constRowCount->getValue();
             }
             else
             {
@@ -423,7 +423,7 @@ namespace Slang
         }
         else if(auto toDeclRefType = as<DeclRefType>(toType))
         {
-            auto toTypeDeclRef = toDeclRefType->declRef;
+            auto toTypeDeclRef = toDeclRefType->getDeclRef();
             if(auto toStructDeclRef = toTypeDeclRef.as<StructDecl>())
             {
                 // Trying to initialize a `struct` type given an initializer list.
@@ -570,7 +570,7 @@ namespace Slang
         if( left == right )
             return true;
 
-        if( left->equalsVal(right) )
+        if( left->equals(right) )
             return true;
 
         return false;
@@ -581,9 +581,9 @@ namespace Slang
     {
         if(!type) return false;
 
-        for( auto m : type->modifiers )
+        for (Index m = 0; m < type->getModifierCount(); m++)
         {
-            if(_doModifiersMatch(m, modifier))
+            if(_doModifiersMatch(type->getModifier(m), modifier))
                 return true;
         }
 
@@ -632,7 +632,7 @@ namespace Slang
     {
         auto basicType = as<BasicExpressionType>(t);
         if (!basicType) return false;
-        switch (basicType->baseType)
+        switch (basicType->getBaseType())
         {
         case BaseType::Int8:
         case BaseType::Int16:
@@ -650,7 +650,7 @@ namespace Slang
         auto basicType = as<BasicExpressionType>(t);
         if (!basicType) return 0;
 
-        switch (basicType->baseType)
+        switch (basicType->getBaseType())
         {
         case BaseType::Int8:
         case BaseType::UInt8:
@@ -770,10 +770,10 @@ namespace Slang
             // on it, but the underlying types are otherwise the same.
             //
             auto toModified = as<ModifiedType>(toType);
-            auto toBase = toModified ? toModified->base : toType;
+            auto toBase = toModified ? toModified->getBase() : toType;
             //
             auto fromModified = as<ModifiedType>(fromType);
-            auto fromBase = fromModified ? fromModified->base : fromType;
+            auto fromBase = fromModified ? fromModified->getBase() : fromType;
 
 
             if((toModified || fromModified) && toBase->equals(fromBase))
@@ -787,8 +787,9 @@ namespace Slang
                 //
                 if( toModified )
                 {
-                    for( auto modifier : toModified->modifiers )
+                    for (Index m = 0; m < toModified->getModifierCount(); m++)
                     {
+                        auto modifier = toModified->getModifier(m);
                         if(_hasMatchingModifier(fromModified, modifier))
                             continue;
 
@@ -804,8 +805,10 @@ namespace Slang
                 }
                 if( fromModified )
                 {
-                    for( auto modifier : fromModified->modifiers )
+                    for (Index m = 0; m < fromModified->getModifierCount(); m++)
                     {
+                        auto modifier = fromModified->getModifier(m);
+
                         if(_hasMatchingModifier(toModified, modifier))
                             continue;
 
@@ -923,7 +926,7 @@ namespace Slang
         //
         // TODO(tfoley): Under what circumstances would this check ever be needed?
         //
-        if (auto toParameterGroupType = as<ParameterGroupType>(toType))
+        if (as<ParameterGroupType>(toType))
         {
             return _failedCoercion(toType, outToExpr, fromExpr);
         }
@@ -1141,7 +1144,7 @@ namespace Slang
                         {
                             if (auto val = as<ConstantIntVal>(intVal))
                             {
-                                if (isIntValueInRangeOfType(val->value, toType))
+                                if (isIntValueInRangeOfType(val->getValue(), toType))
                                 {
                                     // OK.
                                     shouldEmitGeneralWarning = false;
diff --git a/source/slang/slang-check-decl.cpp b/source/slang/slang-check-decl.cpp
index b1dd2d533..b6a5d94ef 100644
--- a/source/slang/slang-check-decl.cpp
+++ b/source/slang/slang-check-decl.cpp
@@ -13,6 +13,8 @@
 #include "slang-lookup.h"
 #include "slang-syntax.h"
 #include "slang-ast-synthesis.h"
+#include "slang-ast-reflect.h"
+
 #include <limits>
 
 namespace Slang
@@ -201,12 +203,6 @@ namespace Slang
         void visitDecl(Decl*) {}
         void visitDeclGroup(DeclGroup*) {}
 
-        Val* resolveVal(Val* val);
-        Type* resolveType(Type* type)
-        {
-            return (Type*)resolveVal(type);
-        }
-
         void visitTypeExp(TypeExp& exp)
         {
             exp.type = resolveType(exp.type);
@@ -581,7 +577,7 @@ namespace Slang
         return getTypeForDeclRef(astBuilder, nullptr, nullptr, declRef, &typeResult, loc);
     }
 
-    DeclRef<ExtensionDecl> ApplyExtensionToType(
+    DeclRef<ExtensionDecl> applyExtensionToType(
         SemanticsVisitor*       semantics,
         ExtensionDecl*          extDecl,
         Type*  type)
@@ -589,118 +585,7 @@ namespace Slang
         if(!semantics)
             return DeclRef<ExtensionDecl>();
 
-        return semantics->ApplyExtensionToType(extDecl, type);
-    }
-
-    GenericSubstitution* createDefaultSubstitutionsForGeneric(
-        ASTBuilder*             astBuilder,
-        SemanticsVisitor* semantics,
-        GenericDecl*            genericDecl,
-        Substitutions*   outerSubst)
-    {
-        GenericSubstitution* cachedResult = nullptr;
-        if (astBuilder->m_genericDefaultSubst.tryGetValue(genericDecl, cachedResult))
-        {
-            if (cachedResult->getOuter() == outerSubst)
-                return cachedResult;
-        }
-
-        List<Val*> args;
-
-        for( auto mm : genericDecl->members )
-        {
-            if( auto genericTypeParamDecl = as<GenericTypeParamDecl>(mm) )
-            {
-                args.add(DeclRefType::create(astBuilder, astBuilder->getSpecializedDeclRef<Decl>(genericTypeParamDecl, outerSubst)));
-            }
-            else if( auto genericValueParamDecl = as<GenericValueParamDecl>(mm) )
-            {
-                if (semantics)
-                    ensureDecl(semantics, genericValueParamDecl, DeclCheckState::ReadyForLookup);
-
-                args.add(astBuilder->getOrCreate<GenericParamIntVal>(
-                    genericValueParamDecl->getType(),
-                    astBuilder->getSpecializedDeclRef(genericValueParamDecl, outerSubst)));
-            }
-        }
-
-        bool shouldCache = true;
-
-        // create default substitution arguments for constraints
-        for (auto mm : genericDecl->members)
-        {
-            if (auto genericTypeConstraintDecl = as<GenericTypeConstraintDecl>(mm))
-            {
-                if (semantics)
-                {
-                    ensureDecl(semantics, genericTypeConstraintDecl, DeclCheckState::ReadyForReference);
-                }
-                auto constraintDeclRef = astBuilder->getSpecializedDeclRef<GenericTypeConstraintDecl>(genericTypeConstraintDecl, outerSubst);
-                auto witness =
-                    astBuilder->getDeclaredSubtypeWitness(
-                        getSub(astBuilder, constraintDeclRef),
-                        getSup(astBuilder, constraintDeclRef),
-                        astBuilder->getSpecializedDeclRef(genericTypeConstraintDecl, outerSubst));
-                // TODO: this is an ugly hack to prevent crashing.
-                // In early stages of compilation witness->sub and witness->sup may not be checked yet.
-                // When semanticVisitor is present we have used that to ensure the type is checked.
-                // However due to how the code is written we cannot guarantee semanticVisitor is always available
-                // here, and if we can't get the checked sup/sub type this subst is incomplete and should not be
-                // cached.
-                if (!witness->sub)
-                    shouldCache = false;
-                args.add(witness);
-            }
-        }
-
-        GenericSubstitution* genericSubst = astBuilder->getOrCreateGenericSubstitution(outerSubst, genericDecl, args);
-        if (shouldCache)
-            astBuilder->m_genericDefaultSubst[genericDecl] = genericSubst;
-        return genericSubst;
-    }
-
-    // Sometimes we need to refer to a declaration the way that it would be specialized
-    // inside the context where it is declared (e.g., with generic parameters filled in
-    // using their archetypes).
-    //
-    SubstitutionSet createDefaultSubstitutions(
-        ASTBuilder*     astBuilder,
-        SemanticsVisitor* semantics,
-        Decl*           decl,
-        SubstitutionSet outerSubstSet)
-    {
-        auto dd = decl->parentDecl;
-        if( auto genericDecl = as<GenericDecl>(dd) )
-        {
-            // We don't want to specialize references to anything
-            // other than the "inner" declaration itself.
-            if(decl != genericDecl->inner)
-                return outerSubstSet;
-
-            GenericSubstitution* genericSubst = createDefaultSubstitutionsForGeneric(
-                astBuilder,
-                semantics,
-                genericDecl,
-                outerSubstSet.substitutions);
-
-            return SubstitutionSet(genericSubst);
-        }
-
-        return outerSubstSet;
-    }
-
-    SubstitutionSet createDefaultSubstitutions(
-        ASTBuilder* astBuilder,
-        SemanticsVisitor* semantics,
-        Decl*   decl)
-    {
-        SubstitutionSet subst;
-        if( auto parentDecl = decl->parentDecl )
-        {
-            subst = createDefaultSubstitutions(astBuilder, semantics, parentDecl);
-        }
-        subst = createDefaultSubstitutions(astBuilder, semantics, decl, subst);
-        return subst;
+        return semantics->applyExtensionToType(extDecl, type);
     }
 
     bool SemanticsVisitor::isDeclUsableAsStaticMember(
@@ -1066,7 +951,7 @@ namespace Slang
                 auto baseExprType = memberExpr->baseExpression->type.type;
                 if (auto typeType = as<TypeType>(baseExprType))
                 {
-                    if (diffThisType->equals(typeType->type))
+                    if (diffThisType->equals(typeType->getType()))
                     {
                         return;
                     }
@@ -1149,7 +1034,6 @@ namespace Slang
         {
             // A variable with an explicit type is simpler, for the
             // most part.
-
             TypeExp typeExp = CheckUsableType(varDecl->type);
             varDecl->type = typeExp;
             if (varDecl->type.equals(m_astBuilder->getVoidType()))
@@ -1256,7 +1140,7 @@ namespace Slang
         {
             if (auto basicType = as<BasicExpressionType>(varDecl->getType()))
             {
-                switch (basicType->baseType)
+                switch (basicType->getBaseType())
                 {
                 case BaseType::Bool:
                 case BaseType::Int8:
@@ -1429,11 +1313,11 @@ namespace Slang
         {
             if (auto declRefType = as<DeclRefType>(sharedTypeExpr->base))
             {
-                auto subst = createDefaultSubstitutions(m_astBuilder, this, declRefType->declRef.getDecl());
-                auto newType = DeclRefType::create(m_astBuilder, m_astBuilder->getSpecializedDeclRef(declRefType->declRef.getDecl(), subst));
+                auto newDeclRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, declRefType->getDeclRef());
+                auto newType = DeclRefType::create(m_astBuilder, newDeclRef);
                 sharedTypeExpr->base.type = newType;
                 if (auto typetype = as<TypeType>(typeExp.exp->type))
-                    typetype->type = newType;
+                    typeExp.exp->type = m_astBuilder->getTypeType(newType);
             }
         }
     }
@@ -1477,20 +1361,20 @@ namespace Slang
         }
 
         // If `This` is nested inside a generic, we need to form a complete declref type to the
-        // newly synthesized aggTypeDecl here. This can be done by obtaining ThisTypeSubstitution
-        // from requirementDeclRef to get the generic substitution for outer generic parameters, and
+        // newly synthesized aggTypeDecl here. This can be done by obtaining the this type witness
+        // from requirementDeclRef to get the generic arguments for the outer generic, and
         // apply it to the newly synthesized decl.
         SubstitutionSet substSet;
-        if (auto thisTypeSusbt = findThisTypeSubstitution(
-            requirementDeclRef.getSubst(),
-            as<InterfaceDecl>(requirementDeclRef.getParent(m_astBuilder)).getDecl()))
+        if (auto thisWitness = findThisTypeWitness(
+            SubstitutionSet(requirementDeclRef),
+            as<InterfaceDecl>(requirementDeclRef.getParent()).getDecl()))
         {
-            if (auto declRefType = as<DeclRefType>(thisTypeSusbt->witness->sub))
+            if (auto declRefType = as<DeclRefType>(thisWitness->getSub()))
             {
-                substSet = declRefType->declRef.getSubst();
+                substSet = SubstitutionSet(declRefType->getDeclRef());
             }
         }
-        auto satisfyingType = DeclRefType::create(m_astBuilder, m_astBuilder->getSpecializedDeclRef(aggTypeDecl, substSet));
+        auto satisfyingType = DeclRefType::create(m_astBuilder, m_astBuilder->getMemberDeclRef(substSet.declRef, aggTypeDecl));
 
         // Helper function to add a `diffType` field into the synthesized type for the original
         // `member`.
@@ -1513,8 +1397,7 @@ namespace Slang
                 fieldLookupExpr->type.type = diffMemberType;
                 auto baseTypeExpr = m_astBuilder->create<SharedTypeExpr>();
                 baseTypeExpr->base.type = differentialType;
-                auto baseTypeType = m_astBuilder->create<TypeType>();
-                baseTypeType->type = differentialType;
+                auto baseTypeType = m_astBuilder->getOrCreate<TypeType>(differentialType);
                 baseTypeExpr->type.type = baseTypeType;
                 fieldLookupExpr->baseExpression = baseTypeExpr;
                 fieldLookupExpr->declRef = makeDeclRef(diffField);
@@ -1529,8 +1412,7 @@ namespace Slang
                 fieldLookupExpr->type.type = diffMemberType;
                 auto baseTypeExpr = m_astBuilder->create<SharedTypeExpr>();
                 baseTypeExpr->base.type = differentialType;
-                auto baseTypeType = m_astBuilder->create<TypeType>();
-                baseTypeType->type = differentialType;
+                auto baseTypeType = m_astBuilder->getOrCreate<TypeType>(differentialType);
                 baseTypeExpr->type.type = baseTypeType;
                 fieldLookupExpr->baseExpression = baseTypeExpr;
                 fieldLookupExpr->declRef = makeDeclRef(diffField);
@@ -1545,7 +1427,7 @@ namespace Slang
         {
             if (auto declRefType = as<DeclRefType>(inheritanceDecl->base.type))
             {
-                if (declRefType->declRef == m_astBuilder->getDifferentiableInterfaceDecl())
+                if (declRefType->getDeclRef() == m_astBuilder->getDifferentiableInterfaceDecl())
                 {
                     hasDifferentialConformance = true;
                     break;
@@ -1590,7 +1472,7 @@ namespace Slang
             if (auto baseDeclRefType = as<DeclRefType>(inheritance->base.type))
             {
                 // Skip interface super types.
-                if (baseDeclRefType->declRef.as<InterfaceDecl>())
+                if (baseDeclRefType->getDeclRef().as<InterfaceDecl>())
                     continue;
                 if (auto superDiffType = tryGetDifferentialType(m_astBuilder, baseDeclRefType))
                 {
@@ -1618,6 +1500,9 @@ namespace Slang
         if (doesTypeSatisfyAssociatedTypeConstraintRequirement(satisfyingType, requirementDeclRef, witnessTable))
         {
             witnessTable->add(requirementDeclRef.getDecl(), RequirementWitness(satisfyingType));
+
+            // Incrase the epoch so that future calls to Type::getCanonicalType will return the up-to-date folded types.
+            m_astBuilder->incrementEpoch();
             return true;
         }
 
@@ -1747,11 +1632,11 @@ namespace Slang
             auto baseType = as<DeclRefType>(inheritanceDecl->witnessTable->baseType);
             if (!baseType)
                 return;
-            if (baseType->declRef.getDecl() != m_astBuilder->getDifferentiableInterfaceDecl().getDecl())
+            if (baseType->getDeclRef().getDecl() != m_astBuilder->getDifferentiableInterfaceDecl().getDecl())
                 return;
             RequirementWitness witnessValue;
             auto requirementDecl = m_astBuilder->getSharedASTBuilder()->findBuiltinRequirementDecl(BuiltinRequirementKind::DifferentialType);
-            if (!inheritanceDecl->witnessTable->requirementDictionary.tryGetValue(requirementDecl, witnessValue))
+            if (!inheritanceDecl->witnessTable->getRequirementDictionary().tryGetValue(requirementDecl, witnessValue))
                 return;
 
             // A type used as differential type must have itself as its own differential type.
@@ -1763,7 +1648,7 @@ namespace Slang
             auto diffDiffType = tryGetDifferentialType(m_astBuilder, differentialType);
             if (!differentialType->equals(diffDiffType))
             {
-                SourceLoc sourceLoc = differentialType->declRef.getDecl()->loc;
+                SourceLoc sourceLoc = differentialType->getDeclRef().getDecl()->loc;
                 getSink()->diagnose(sourceLoc, Diagnostics::differentialTypeShouldServeAsItsOwnDifferentialType, differentialType);
                 getSink()->diagnose(inheritanceDecl, Diagnostics::noteSeeUseOfDifferentialType, differentialType, inheritanceDecl->getSup());
             }
@@ -2287,7 +2172,7 @@ namespace Slang
                 auto satisfyingVal = m_astBuilder->getOrCreate<GenericParamIntVal>(
                     requiredValueParamDeclRef.getDecl()->getType(),
                     satisfyingValueParamDeclRef);
-                satisfyingVal->declRef = satisfyingValueParamDeclRef;
+                satisfyingVal->getDeclRef() = satisfyingValueParamDeclRef;
 
                 requiredSubstArgs.add(satisfyingVal);
             }
@@ -2311,21 +2196,16 @@ namespace Slang
             }
         }
 
-        GenericSubstitution* requiredSubst = m_astBuilder->getOrCreateGenericSubstitution(
-            requiredGenericDeclRef.getSubst(),
-            requiredGenericDeclRef.getDecl(),
-            requiredSubstArgs);
-
         // Now that we have computed a set of specialization arguments that will
         // specialize the generic requirement at the type parameters of the satisfying
         // generic, we can construct a reference to that declaration and re-run some
         // of the earlier checking logic with more type information usable.
         //
-        auto specializedRequiredGenericDeclRef = m_astBuilder->getSpecializedDeclRef<GenericDecl>(requiredGenericDeclRef.getDecl(), requiredSubst);
-        auto specializedRequiredMemberDeclRefs = getMembers(m_astBuilder, specializedRequiredGenericDeclRef);
+        auto specializedRequiredGenericInnerDeclRef = m_astBuilder->getGenericAppDeclRef(
+            requiredGenericDeclRef, requiredSubstArgs.getArrayView());
         for (Index i = 0; i < memberCount; i++)
         {
-            auto requiredMemberDeclRef = specializedRequiredMemberDeclRefs[i];
+            auto requiredMemberDeclRef = requiredMemberDeclRefs[i];
             auto satisfyingMemberDeclRef = satisfyingMemberDeclRefs[i];
 
             if(auto requiredTypeParamDeclRef = requiredMemberDeclRef.as<GenericTypeParamDecl>())
@@ -2365,13 +2245,16 @@ namespace Slang
                 // In current code the sub type will always be one of the generic type parameters,
                 // and the super-type will always be an interface, but there should be no
                 // need to make use of those additional details here.
-
-                auto requiredSubType = getSub(m_astBuilder, requiredConstraintDeclRef);
+                auto specializedRequiredConstraintDeclRef = m_astBuilder->getGenericAppDeclRef(
+                    requiredGenericDeclRef,
+                    requiredSubstArgs.getArrayView(),
+                    requiredConstraintDeclRef.getDecl()).as<GenericTypeConstraintDecl>();
+                auto requiredSubType = getSub(m_astBuilder, specializedRequiredConstraintDeclRef);
                 auto satisfyingSubType = getSub(m_astBuilder, satisfyingConstraintDeclRef);
                 if (!satisfyingSubType->equals(requiredSubType))
                     return false;
 
-                auto requiredSuperType = getSup(m_astBuilder, requiredConstraintDeclRef);
+                auto requiredSuperType = getSup(m_astBuilder, specializedRequiredConstraintDeclRef);
                 auto satisfyingSuperType = getSup(m_astBuilder, satisfyingConstraintDeclRef);
                 if (!satisfyingSuperType->equals(requiredSuperType))
                     return false;
@@ -2400,8 +2283,8 @@ namespace Slang
         // declaration (whatever it is) for an exact match.
         //
         return doesMemberSatisfyRequirement(
-            m_astBuilder->getSpecializedDeclRef<Decl>(satisfyingGenericDeclRef.getDecl()->inner, satisfyingGenericDeclRef.getSubst()),
-            m_astBuilder->getSpecializedDeclRef<Decl>(requiredGenericDeclRef.getDecl()->inner, requiredSubst),
+            m_astBuilder->getMemberDeclRef(satisfyingGenericDeclRef, getInner(satisfyingGenericDeclRef)),
+            specializedRequiredGenericInnerDeclRef,
             witnessTable);
     }
 
@@ -2444,7 +2327,7 @@ namespace Slang
         {
             // If we are seeing a placeholder that awaits synthesis, return false now to trigger
             // auto synthesis.
-            if (declRefType->declRef.getDecl()->hasModifier<ToBeSynthesizedModifier>())
+            if (declRefType->getDeclRef().getDecl()->hasModifier<ToBeSynthesizedModifier>())
                 return false;
         }
         // We need to confirm that the chosen type `satisfyingType`,
@@ -2466,7 +2349,7 @@ namespace Slang
             // type can indeed satisfy the interface requirement.
             witnessTable->add(
                 requiredAssociatedTypeDeclRef.getDecl(),
-                RequirementWitness(satisfyingType));
+                RequirementWitness(satisfyingType->getCanonicalType()));
         }
 
         return conformance;
@@ -2563,7 +2446,7 @@ namespace Slang
             // check if the specified type satisfies the constraints defined by the associated type
             if (auto requiredTypeDeclRef = requiredMemberDeclRef.as<AssocTypeDecl>())
             {
-                ensureDecl(typedefDeclRef, DeclCheckState::CanUseAsType);
+                ensureDecl(typedefDeclRef, DeclCheckState::ReadyForLookup);
 
                 auto satisfyingType = getNamedType(m_astBuilder, typedefDeclRef);
                 return doesTypeSatisfyAssociatedTypeRequirement(satisfyingType, requiredTypeDeclRef, witnessTable);
@@ -2648,9 +2531,6 @@ namespace Slang
         {
             if (auto constraintDecl = as<GenericTypeConstraintDecl>(member))
             {
-                getASTBuilder()->getSpecializedDeclRef(
-                    constraintDecl, requiredMemberDeclRef.getSubst());
-
                 auto synConstraintDecl = m_astBuilder->create<GenericTypeConstraintDecl>();
                 synConstraintDecl->nameAndLoc = constraintDecl->getNameAndLoc();
                 synConstraintDecl->parentDecl = synGenericDecl;
@@ -2658,7 +2538,7 @@ namespace Slang
                 // For constraints of type T : Interface, where T is a simple type parameter, 
                 // find the declaration of T
                 // 
-                if (auto typeParamDecl = as<DeclRefType>(constraintDecl->sub.type)->declRef.as<GenericTypeParamDecl>().getDecl())
+                if (auto typeParamDecl = as<DeclRefType>(constraintDecl->sub.type)->getDeclRef().as<GenericTypeParamDecl>().getDecl())
                 {  
                     auto synTypeParamDecl = mapOrigToSynTypeParams[typeParamDecl];
 
@@ -2680,37 +2560,19 @@ namespace Slang
             }
         }
 
-        // Get outer substitutions. (This inner-most substition 
-        // must be a ThisTypeSubstition)
-        // 
-        Substitutions* outer = nullptr;
-        if (auto thisTypeSubst = findThisTypeSubstitution(
-            requiredMemberDeclRef.getSubst(),
-            as<InterfaceDecl>(requiredMemberDeclRef.getParent(m_astBuilder)).getDecl()))
-        {
-            outer = thisTypeSubst;
-        }
-
         // Override generic pointer to point to the original generic container.
         // This will create a substitution of the synthesized parameters for the
         // original parameters.
-        // 
-        GenericSubstitution* requiredFuncSubsts = createDefaultSubstitutionsForGeneric(m_astBuilder, this, requiredMemberDeclRef.getDecl(), outer);
-        DeclRef<Decl> requiredFuncDeclRef = m_astBuilder->getSpecializedDeclRef(requiredMemberDeclRef.getDecl()->inner, requiredFuncSubsts);
-
-        GenericSubstitution* substSynParamsForOrigGeneric = m_astBuilder->getOrCreateGenericSubstitution(
-            outer,
-            requiredMemberDeclRef.getDecl(),
-            createDefaultSubstitutionsForGeneric(m_astBuilder, this, synGenericDecl, nullptr)->getArgs());
-
-        // Substitute parameters of the synthesized generic for the parameters of the original generic.
-        requiredFuncDeclRef = substituteDeclRef(substSynParamsForOrigGeneric, m_astBuilder, requiredFuncDeclRef);
+        //
+        auto defaultArgs = getDefaultSubstitutionArgs(m_astBuilder, this, synGenericDecl);
+        DeclRef<FuncDecl> requiredFuncDeclRef = m_astBuilder->getGenericAppDeclRef(
+                requiredMemberDeclRef, defaultArgs.getArrayView()).as<FuncDecl>();
 
-        SLANG_ASSERT(requiredFuncDeclRef.as<FuncDecl>());
+        SLANG_ASSERT(requiredFuncDeclRef);
 
         synGenericDecl->inner = synthesizeMethodSignatureForRequirementWitness(
             context,
-            requiredFuncDeclRef.as<FuncDecl>(),
+            requiredFuncDeclRef,
             synArgs,
             synThis);
         synGenericDecl->inner->parentDecl = synGenericDecl;
@@ -2860,14 +2722,12 @@ namespace Slang
         {
             if (auto fwdReq = as<ForwardDerivativeRequirementDecl>(reqRefDecl->referencedDecl))
             {
-                ForwardDifferentiateVal* val = m_astBuilder->create<ForwardDifferentiateVal>();
-                val->func = satisfyingMemberDeclRef;
+                ForwardDifferentiateVal* val = m_astBuilder->getOrCreate<ForwardDifferentiateVal>(satisfyingMemberDeclRef);
                 witnessTable->add(fwdReq, RequirementWitness(val));
             }
             else if (auto bwdReq = as<BackwardDerivativeRequirementDecl>(reqRefDecl->referencedDecl))
             {
-                DifferentiateVal* val = m_astBuilder->create<BackwardDifferentiateVal>();
-                val->func = satisfyingMemberDeclRef;
+                DifferentiateVal* val = m_astBuilder->getOrCreate<BackwardDifferentiateVal>(satisfyingMemberDeclRef);
                 witnessTable->add(bwdReq, RequirementWitness(val));
             }
         }
@@ -3127,7 +2987,7 @@ namespace Slang
         // or uses, an associated type or `This`.
         //
         // Ideally we should be looking up the type using a `DeclRef` that
-        // refers to the interface requirement using a `ThisTypeSubstitution`
+        // refers to the interface requirement using a `LookupDeclRef`
         // that refers to the satisfying type declaration, and requirement
         // checking for non-associated-type requirements should be done *after*
         // requirement checking for associated-type requirements.
@@ -3577,7 +3437,7 @@ namespace Slang
 
         // First we need to make sure the associated `Differential` type requirement is satisfied.
         bool hasDifferentialAssocType = false;
-        for (auto existingEntry : witnessTable->requirementDictionary)
+        for (auto& existingEntry : witnessTable->getRequirementDictionary())
         {
             if (auto builtinReqAttr = existingEntry.key->findModifier<BuiltinRequirementModifier>())
             {
@@ -3726,20 +3586,33 @@ namespace Slang
 
         // If `This` is nested inside a generic, we need to form a complete declref type to the
         // newly synthesized method here in order to fill into the witness table.
-        // This can be done by obtaining ThisTypeSubstitution from requirementDeclRef to get the
+        // This can be done by obtaining the ThisType witness from requirementDeclRef to get the
         // generic substitution for outer generic parameters, and apply it here.
         SubstitutionSet substSet;
-        if (auto thisTypeSubst = findThisTypeSubstitution(
-            requirementDeclRef.getSubst(),
+        if (auto thisTypeWitness = findThisTypeWitness(
+            SubstitutionSet(requirementDeclRef),
             as<InterfaceDecl>(requirementDeclRef.getDecl()->parentDecl)))
         {
-            if (auto declRefType = as<DeclRefType>(thisTypeSubst->witness->sub))
+            if (auto declRefType = as<DeclRefType>(thisTypeWitness->getSub()))
             {
-                substSet = declRefType->declRef.getSubst();
+                substSet = SubstitutionSet(declRefType->getDeclRef());
             }
         }
+        if (auto outerGeneric = GetOuterGeneric(context->parentDecl))
+        {
+            // If the context->parentDecl is not the same as ThisType represented by genApp, then it must be an extension
+            // to ThisType. In this case, we need to form a new GenericAppDeclRef to specailizethe outer parent extension
+            // decl. Note that the extension might be a partial extension with some generic arguments missing, and
+            // we can't support that case right now. For now we can just assume the extension will have the same set
+            // of generic parameters as the target type.
+            auto defaultArgs = getDefaultSubstitutionArgs(m_astBuilder, this, outerGeneric);
+            auto specializedParent = m_astBuilder->getGenericAppDeclRef(makeDeclRef(outerGeneric), defaultArgs.getArrayView());
+            auto specializedFunc = m_astBuilder->getMemberDeclRef(specializedParent, synFunc);
+            witnessTable->add(requirementDeclRef.getDecl(), RequirementWitness(specializedFunc));
+            return true;
+        }
 
-        witnessTable->add(requirementDeclRef.getDecl(), RequirementWitness(m_astBuilder->getSpecializedDeclRef<Decl>(synFunc, substSet)));
+        witnessTable->add(requirementDeclRef.getDecl(), RequirementWitness(m_astBuilder->getDirectDeclRef(synFunc)));
         return true;
     }
 
@@ -3767,11 +3640,16 @@ namespace Slang
         // witness in the table for the requirement, so
         // that we can bail out early.
         //
-        if(witnessTable->requirementDictionary.containsKey(requiredMemberDeclRef.getDecl()))
+        if(witnessTable->getRequirementDictionary().containsKey(requiredMemberDeclRef.getDecl()))
         {
             return true;
         }
 
+        // The ThisType requirement is always satisfied.
+        if (as<ThisTypeDecl>(requiredMemberDeclRef.getDecl()))
+        {
+            return true;
+        }
 
         // An important exception to the above is that an
         // inheritance declaration in the interface is not going
@@ -3987,17 +3865,13 @@ namespace Slang
         ensureDecl(superInterfaceDeclRef, DeclCheckState::CanReadInterfaceRequirements);
 
         // When comparing things like signatures, we need to do so in the context
-        // of a this-type substitution that aligns the signatures in the interface
+        // of a LookupDeclRef that aligns the signatures in the interface
         // with those in the concrete type. For example, we need to treat any uses
         // of `This` in the interface as equivalent to the concrete type for the
         // purpose of signature matching (and similarly for associated types).
         //
-        ThisTypeSubstitution* thisTypeSubst = m_astBuilder->getOrCreateThisTypeSubstitution(
-            superInterfaceDeclRef.getDecl(),
-            subTypeConformsToSuperInterfaceWitness,
-            superInterfaceDeclRef.getSubst());
-
-        auto specializedSuperInterfaceDeclRef = m_astBuilder->getSpecializedDeclRef<InterfaceDecl>(superInterfaceDeclRef.getDecl(), thisTypeSubst);
+        auto thisTypeDeclRef = m_astBuilder->getLookupDeclRef(
+            subTypeConformsToSuperInterfaceWitness, superInterfaceDeclRef.getDecl()->getThisTypeDecl());
 
         bool result = true;
 
@@ -4029,35 +3903,36 @@ namespace Slang
         // constraints and solve for those type variables as part of the
         // conformance-checking process.
         //
-        for(auto requiredMemberDeclRef : getMembers(m_astBuilder, specializedSuperInterfaceDeclRef))
+        for(auto requiredMemberDecl : getMembers(m_astBuilder, superInterfaceDeclRef))
         {
-            if(!isAssociatedTypeDecl(requiredMemberDeclRef.getDecl()))
+            if(!isAssociatedTypeDecl(requiredMemberDecl.getDecl()))
                 continue;
-
+            auto requiredMemberDeclRef = m_astBuilder->getLookupDeclRef(subTypeConformsToSuperInterfaceWitness, requiredMemberDecl.getDecl());
             auto requirementSatisfied = findWitnessForInterfaceRequirement(
                 context,
                 subType,
                 superInterfaceType,
                 inheritanceDecl,
-                specializedSuperInterfaceDeclRef,
+                thisTypeDeclRef,
                 requiredMemberDeclRef,
                 witnessTable,
                 subTypeConformsToSuperInterfaceWitness);
 
             result = result && requirementSatisfied;
         }
-        for(auto requiredMemberDeclRef : getMembers(m_astBuilder, specializedSuperInterfaceDeclRef))
+        for(auto requiredMemberDecl : getMembers(m_astBuilder, superInterfaceDeclRef))
         {
-            if(isAssociatedTypeDecl(requiredMemberDeclRef.getDecl()))
+            if(isAssociatedTypeDecl(requiredMemberDecl.getDecl()))
                 continue;
-            if (requiredMemberDeclRef.as<DerivativeRequirementDecl>())
+            if (requiredMemberDecl.as<DerivativeRequirementDecl>())
                 continue;
+            auto requiredMemberDeclRef = m_astBuilder->getLookupDeclRef(subTypeConformsToSuperInterfaceWitness, requiredMemberDecl.getDecl());
             auto requirementSatisfied = findWitnessForInterfaceRequirement(
                 context,
                 subType,
                 superInterfaceType,
                 inheritanceDecl,
-                specializedSuperInterfaceDeclRef,
+                thisTypeDeclRef,
                 requiredMemberDeclRef,
                 witnessTable,
                 subTypeConformsToSuperInterfaceWitness);
@@ -4089,25 +3964,27 @@ namespace Slang
         // the time we are compiling and handle those, and punt on the larger issue
         // for a bit longer.
         //
-        for(auto candidateExt : getCandidateExtensions(specializedSuperInterfaceDeclRef, this))
+        for(auto candidateExt : getCandidateExtensions(superInterfaceDeclRef, this))
         {
             // We need to apply the extension to the interface type that our
             // concrete type is inheriting from.
             //
-            Type* targetType = DeclRefType::create(m_astBuilder, specializedSuperInterfaceDeclRef);
-            auto extDeclRef = ApplyExtensionToType(candidateExt, targetType);
-            if(!extDeclRef)
+            Type* targetType = DeclRefType::create(m_astBuilder, thisTypeDeclRef);
+            auto parentDeclRef = applyExtensionToType(candidateExt, targetType);
+            if(!parentDeclRef)
                 continue;
 
             // Only inheritance clauses from the extension matter right now.
-            for(auto requiredInheritanceDeclRef : getMembersOfType<InheritanceDecl>(m_astBuilder, extDeclRef))
+            for(auto requiredInheritanceDecl : getMembersOfType<InheritanceDecl>(m_astBuilder, candidateExt))
             {
+                auto requiredInheritanceDeclRef = m_astBuilder->getLookupDeclRef(
+                    subTypeConformsToSuperInterfaceWitness, requiredInheritanceDecl.getDecl());
                 auto requirementSatisfied = findWitnessForInterfaceRequirement(
                     context,
                     subType,
                     superInterfaceType,
                     inheritanceDecl,
-                    specializedSuperInterfaceDeclRef,
+                    thisTypeDeclRef,
                     requiredInheritanceDeclRef,
                     witnessTable,
                     subTypeConformsToSuperInterfaceWitness);
@@ -4131,7 +4008,7 @@ namespace Slang
     {
         if (auto supereclRefType = as<DeclRefType>(superType))
         {
-            auto superTypeDeclRef = supereclRefType->declRef;
+            auto superTypeDeclRef = supereclRefType->getDeclRef();
             if (auto superInterfaceDeclRef = superTypeDeclRef.as<InterfaceDecl>())
             {
                 // The type is stating that it conforms to an interface.
@@ -4172,11 +4049,11 @@ namespace Slang
 
         if( auto declRefType = as<DeclRefType>(subType) )
         {
-            auto declRef = declRefType->declRef;
+            auto declRef = declRefType->getDeclRef();
 
             if (auto superDeclRefType = as<DeclRefType>(superType))
             {
-                auto superTypeDecl = superDeclRefType->declRef.getDecl();
+                auto superTypeDecl = superDeclRefType->getDeclRef().getDecl();
                 if (superTypeDecl->findModifier<ComInterfaceAttribute>())
                 {
                     // A struct cannot implement a COM Interface.
@@ -4228,10 +4105,7 @@ namespace Slang
         // Look at the type being inherited from, and validate
         // appropriately.
 
-        DeclaredSubtypeWitness* subIsSuperWitness = m_astBuilder->create<DeclaredSubtypeWitness>();
-        subIsSuperWitness->declRef = makeDeclRef(inheritanceDecl);
-        subIsSuperWitness->sub = subType;
-        subIsSuperWitness->sup = superType;
+        DeclaredSubtypeWitness* subIsSuperWitness = m_astBuilder->getDeclaredSubtypeWitness(subType, superType, makeDeclRef(inheritanceDecl));
 
         ConformanceCheckingContext context;
         context.conformingType = subType;
@@ -4333,7 +4207,7 @@ namespace Slang
         {
             return;
         }
-        auto baseDecl = baseDeclRefType->declRef.getDecl();
+        auto baseDecl = baseDeclRefType->getDeclRef().getDecl();
 
         // Using the parent/child hierarchy baked into `Decl`s we
         // can find the modules that contain both the `decl` doing
@@ -4415,7 +4289,7 @@ namespace Slang
                 continue;
             }
 
-            auto baseDeclRef = baseDeclRefType->declRef;
+            auto baseDeclRef = baseDeclRefType->getDeclRef();
             auto baseInterfaceDeclRef = baseDeclRef.as<InterfaceDecl>();
             if( !baseInterfaceDeclRef )
             {
@@ -4476,7 +4350,7 @@ namespace Slang
                 continue;
             }
 
-            auto baseDeclRef = baseDeclRefType->declRef;
+            auto baseDeclRef = baseDeclRefType->getDeclRef();
             if( auto baseInterfaceDeclRef = baseDeclRef.as<InterfaceDecl>() )
             {
             }
@@ -4545,7 +4419,7 @@ namespace Slang
                 continue;
             }
 
-            auto baseDeclRef = baseDeclRefType->declRef;
+            auto baseDeclRef = baseDeclRefType->getDeclRef();
             if (auto baseInterfaceDeclRef = baseDeclRef.as<InterfaceDecl>())
             {
             }
@@ -4594,8 +4468,8 @@ namespace Slang
         auto basicType = as<BasicExpressionType>(type);
         if(!basicType)
             return false;
-
-        return isIntegerBaseType(basicType->baseType) || basicType->baseType == BaseType::Bool;
+        auto baseType = basicType->getBaseType();
+        return isIntegerBaseType(baseType) || baseType == BaseType::Bool;
     }
 
     bool SemanticsVisitor::isIntValueInRangeOfType(IntegerLiteralValue value, Type* type)
@@ -4604,7 +4478,7 @@ namespace Slang
         if (!basicType)
             return false;
 
-        switch (basicType->baseType)
+        switch (basicType->getBaseType())
         {
         case BaseType::UInt8:
             return (value >= 0 && value <= std::numeric_limits<uint8_t>::max()) || (value == -1);
@@ -4686,7 +4560,7 @@ namespace Slang
                 continue;
             }
 
-            auto baseDeclRef = baseDeclRefType->declRef;
+            auto baseDeclRef = baseDeclRefType->getDeclRef();
             if( auto baseInterfaceDeclRef = baseDeclRef.as<InterfaceDecl>() )
             {
                 _validateCrossModuleInheritance(decl, inheritanceDecl);
@@ -4790,7 +4664,7 @@ namespace Slang
             Decl* tagAssociatedTypeDecl = nullptr;
             if(auto enumTypeTypeDeclRefType = dynamicCast<DeclRefType>(enumTypeType))
             {
-                if(auto enumTypeTypeInterfaceDecl = as<InterfaceDecl>(enumTypeTypeDeclRefType->declRef.getDecl()))
+                if(auto enumTypeTypeInterfaceDecl = as<InterfaceDecl>(enumTypeTypeDeclRefType->getDeclRef().getDecl()))
                 {
                     for(auto memberDecl : enumTypeTypeInterfaceDecl->members)
                     {
@@ -4861,7 +4735,7 @@ namespace Slang
                 {
                     if(auto constIntVal = as<ConstantIntVal>(explicitTagVal))
                     {
-                        defaultTag = constIntVal->value;
+                        defaultTag = constIntVal->getValue();
                     }
                     else
                     {
@@ -5015,7 +4889,7 @@ namespace Slang
     bool SemanticsVisitor::doGenericSignaturesMatch(
         GenericDecl*                    left,
         GenericDecl*                    right,
-        GenericSubstitution**    outSubstRightToLeft)
+        DeclRef<Decl>*                  outSpecializedRightInner)
     {
         // Our first goal here is to determine if `left` and
         // `right` have equivalent lists of explicit
@@ -5133,9 +5007,9 @@ namespace Slang
         // `foo2<T>` so that its constraint, after specialization,
         // looks like `T : IFoo`.
         //
-        auto& substRightToLeft = *outSubstRightToLeft;
-        List<Val*> leftArgs = getDefaultSubstitutionArgs(left);
-        substRightToLeft = getASTBuilder()->getOrCreateGenericSubstitution(nullptr, right, leftArgs);
+        auto& substInnerRightToLeft = *outSpecializedRightInner;
+        List<Val*> leftArgs = getDefaultSubstitutionArgs(m_astBuilder, this, left);
+        substInnerRightToLeft = m_astBuilder->getGenericAppDeclRef(makeDeclRef(right), leftArgs.getArrayView());
 
         // We should now be able to enumerate the constraints
         // on `right` in a way that uses the same type parameters
@@ -5207,7 +5081,9 @@ namespace Slang
             // arguments into account.
             //
             GenericTypeConstraintDecl* leftConstraint = leftConstraints[cc];
-            DeclRef<GenericTypeConstraintDecl> rightConstraint = m_astBuilder->getSpecializedDeclRef(rightConstraints[cc], substRightToLeft);
+            auto unspecializedRightConstarintDeclRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, makeDeclRef(rightConstraints[cc]));
+            DeclRef<GenericTypeConstraintDecl> rightConstraint = substInnerRightToLeft.substitute(
+                m_astBuilder, unspecializedRightConstarintDeclRef).as<GenericTypeConstraintDecl>();
 
             // For now, every constraint has the form `sub : sup`
             // to indicate that `sub` must be a subtype of `sup`.
@@ -5277,44 +5153,59 @@ namespace Slang
         return true;
     }
 
-    List<Val*> SemanticsVisitor::getDefaultSubstitutionArgs(GenericDecl* genericDecl)
+    List<Val*> getDefaultSubstitutionArgs(ASTBuilder* astBuilder, SemanticsVisitor* semantics, GenericDecl* genericDecl)
     {
         List<Val*> args;
-        for (auto dd : genericDecl->members)
-        {
-            if (dd == genericDecl->inner)
-                continue;
+        if (astBuilder->m_cachedGenericDefaultArgs.tryGetValue(genericDecl, args))
+            return args;
 
-            if (auto typeParam = as<GenericTypeParamDecl>(dd))
+        for (auto mm : genericDecl->members)
+        {
+            if (auto genericTypeParamDecl = as<GenericTypeParamDecl>(mm))
             {
-                auto type = DeclRefType::create(m_astBuilder, makeDeclRef(typeParam));
-                args.add(type);
+                args.add(DeclRefType::create(astBuilder, astBuilder->getDirectDeclRef(genericTypeParamDecl)));
             }
-            else if (auto valueParam = as<GenericValueParamDecl>(dd))
+            else if (auto genericValueParamDecl = as<GenericValueParamDecl>(mm))
             {
-                auto val = m_astBuilder->getOrCreate<GenericParamIntVal>(
-                    valueParam->getType(),
-                    DeclRef<VarDeclBase>(valueParam));
-                args.add(val);
+                if (semantics)
+                    semantics->ensureDecl(genericValueParamDecl, DeclCheckState::ReadyForLookup);
+
+                args.add(astBuilder->getOrCreate<GenericParamIntVal>(
+                    genericValueParamDecl->getType(),
+                    astBuilder->getDirectDeclRef(genericValueParamDecl)));
             }
         }
 
-        // Add defaults for constraint parameters.
-        for (auto dd : genericDecl->members)
+        bool shouldCache = true;
+
+        // create default substitution arguments for constraints
+        for (auto mm : genericDecl->members)
         {
-            if (auto constraintDecl = as<GenericTypeConstraintDecl>(dd))
+            if (auto genericTypeConstraintDecl = as<GenericTypeConstraintDecl>(mm))
             {
-                // Convert the constraint to an appropriate witness.
-                auto witness = tryGetSubtypeWitness(constraintDecl->sub, constraintDecl->sup);
-
-                // Must be non-null since we know there's a constraint. If null, something is 
-                // very wrong.
-                //
-                SLANG_ASSERT(witness);
-
+                if (semantics)
+                    semantics->ensureDecl(genericTypeConstraintDecl, DeclCheckState::ReadyForReference);
+                auto constraintDeclRef = astBuilder->getDirectDeclRef<GenericTypeConstraintDecl>(genericTypeConstraintDecl);
+                auto witness =
+                    astBuilder->getDeclaredSubtypeWitness(
+                        getSub(astBuilder, constraintDeclRef),
+                        getSup(astBuilder, constraintDeclRef),
+                        constraintDeclRef);
+                // TODO: this is an ugly hack to prevent crashing.
+                // In early stages of compilation witness->sub and witness->sup may not be checked yet.
+                // When semanticVisitor is present we have used that to ensure the type is checked.
+                // However due to how the code is written we cannot guarantee semanticVisitor is always available
+                // here, and if we can't get the checked sup/sub type this subst is incomplete and should not be
+                // cached.
+                if (!witness->getSub())
+                    shouldCache = false;
                 args.add(witness);
             }
         }
+
+        if (shouldCache)
+            astBuilder->m_cachedGenericDefaultArgs[genericDecl] = args;
+
         return args;
     }
 
@@ -5442,11 +5333,11 @@ namespace Slang
             // Then we will compare the parameter types of `foo2`
             // against the specialization `foo1<U>`.
             //
-            GenericSubstitution* subst = nullptr;
-            if(!doGenericSignaturesMatch(newGenericDecl, oldGenericDecl, &subst))
+            DeclRef<Decl> specializedOldDeclInner;
+            if(!doGenericSignaturesMatch(newGenericDecl, oldGenericDecl, &specializedOldDeclInner))
                 return SLANG_OK;
 
-            oldDeclRef = getASTBuilder()->getSpecializedDeclRef(oldDecl, subst);
+            oldDeclRef = specializedOldDeclInner.as<FuncDecl>();
         }
 
         // If the parameter signatures don't match, then don't worry
@@ -5869,7 +5760,7 @@ namespace Slang
                 auto reqDecl = m_astBuilder->create<ForwardDerivativeRequirementDecl>();
                 reqDecl->originalRequirementDecl = decl;
                 cloneModifiers(reqDecl, decl);
-                auto declRef = m_astBuilder->getSpecializedDeclRef<CallableDecl>(decl, createDefaultSubstitutions(m_astBuilder, this, decl));
+                auto declRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, makeDeclRef(decl)).as<CallableDecl>();
                 auto diffFuncType = getForwardDiffFuncType(getFuncType(m_astBuilder, declRef));
                 setFuncTypeIntoRequirementDecl(reqDecl, as<FuncType>(diffFuncType));
                 interfaceDecl->members.add(reqDecl);
@@ -5884,7 +5775,7 @@ namespace Slang
             if (decl->hasModifier<BackwardDifferentiableAttribute>())
             {
                 // Requirement for backward derivative.
-                auto declRef = m_astBuilder->getSpecializedDeclRef<CallableDecl>(decl, createDefaultSubstitutions(m_astBuilder, this, decl));
+                auto declRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, makeDeclRef(decl)).as<CallableDecl>();
                 auto originalFuncType = getFuncType(m_astBuilder, declRef);
                 auto diffFuncType = as<FuncType>(getBackwardDiffFuncType(originalFuncType));
                 {
@@ -5953,7 +5844,7 @@ namespace Slang
     IntegerLiteralValue SemanticsVisitor::GetMinBound(IntVal* val)
     {
         if (auto constantVal = as<ConstantIntVal>(val))
-            return constantVal->value;
+            return constantVal->getValue();
 
         // TODO(tfoley): Need to track intervals so that this isn't just a lie...
         return 1;
@@ -6024,7 +5915,7 @@ namespace Slang
         if (auto targetDeclRefType = as<DeclRefType>(decl->targetType))
         {
             // Attach our extension to that type as a candidate...
-            if (auto aggTypeDeclRef = targetDeclRefType->declRef.as<AggTypeDecl>())
+            if (auto aggTypeDeclRef = targetDeclRefType->getDeclRef().as<AggTypeDecl>())
             {
                 auto aggTypeDecl = aggTypeDeclRef.getDecl();
 
@@ -6075,7 +5966,7 @@ namespace Slang
                 continue;
             }
 
-            auto baseDeclRef = baseDeclRefType->declRef;
+            auto baseDeclRef = baseDeclRefType->getDeclRef();
             auto baseInterfaceDeclRef = baseDeclRef.as<InterfaceDecl>();
             if( !baseInterfaceDeclRef )
             {
@@ -6106,9 +5997,9 @@ namespace Slang
             // conform to the interface and fill in its
             // requirements.
             //
-            ThisType* thisType = m_astBuilder->create<ThisType>();
-            thisType->interfaceDeclRef = interfaceDeclRef;
-            return thisType;
+            return DeclRefType::create(
+                m_astBuilder,
+                m_astBuilder->getDirectDeclRef(interfaceDeclRef.getDecl()->getThisTypeDecl()));
         }
         else if (auto aggTypeDeclRef = declRef.as<AggTypeDecl>())
         {
@@ -6159,7 +6050,7 @@ namespace Slang
     {
         if( auto declRefType = as<DeclRefType>(type) )
         {
-            return calcThisType(declRefType->declRef);
+            return calcThisType(declRefType->getDeclRef());
         }
         else
         {
@@ -6404,7 +6295,7 @@ namespace Slang
         return parentGeneric;
     }
 
-    DeclRef<ExtensionDecl> SemanticsVisitor::ApplyExtensionToType(
+    DeclRef<ExtensionDecl> SemanticsVisitor::applyExtensionToType(
         ExtensionDecl*  extDecl,
         Type*    type)
     {
@@ -6438,15 +6329,15 @@ namespace Slang
 
             if (!TryUnifyTypes(constraints, extDecl->targetType.Ptr(), type))
                 return DeclRef<ExtensionDecl>();
-            auto constraintSubst = trySolveConstraintSystem(&constraints, makeDeclRef(extGenericDecl));
-            if (!constraintSubst)
+            auto solvedDeclRef = trySolveConstraintSystem(&constraints, makeDeclRef(extGenericDecl), ArrayView<Val*>());
+            if (!solvedDeclRef)
             {
                 return DeclRef<ExtensionDecl>();
             }
 
             // Construct a reference to the extension with our constraint variables
             // set as they were found by solving the constraint system.
-            extDeclRef = m_astBuilder->getSpecializedDeclRef<Decl>(extDecl, constraintSubst).as<ExtensionDecl>();
+            extDeclRef = solvedDeclRef.as<ExtensionDecl>();
         }
 
         // Now extract the target type from our (possibly specialized) extension decl-ref.
@@ -6458,67 +6349,21 @@ namespace Slang
         // substitution to the extension decl-ref.
         if(auto targetDeclRefType = as<DeclRefType>(targetType))
         {
-            if(auto targetInterfaceDeclRef = targetDeclRefType->declRef.as<InterfaceDecl>())
+            if(auto targetInterfaceDeclRef = targetDeclRefType->getDeclRef().as<InterfaceDecl>())
             {
                 // Okay, the target type is an interface.
                 //
-                // Is the type we want to apply to also an interface?
-                if(auto appDeclRefType = as<DeclRefType>(type))
+                // Is the type we want to apply to a ThisType?
+                if(auto appDeclRefType = as<ThisType>(type))
                 {
-                    if(auto appInterfaceDeclRef = appDeclRefType->declRef.as<InterfaceDecl>())
+                    if(auto thisTypeLookupDeclRef = SubstitutionSet(appDeclRefType->getDeclRef()).findLookupDeclRef())
                     {
-                        if(appInterfaceDeclRef.getDecl() == targetInterfaceDeclRef.getDecl())
+                        if(thisTypeLookupDeclRef->getDecl() == targetInterfaceDeclRef.getDecl())
                         {
                             // Looks like we have a match in the types,
-                            // now let's see if we have a this-type substitution.
-                            if(auto appThisTypeSubst = as<ThisTypeSubstitution>(appInterfaceDeclRef.getSubst()))
-                            {
-                                if(appThisTypeSubst->interfaceDecl == appInterfaceDeclRef.getDecl())
-                                {
-                                    // The type we want to apply to has a this-type substitution,
-                                    // and (by construction) the target type currently does not.
-                                    //
-                                    SLANG_ASSERT(!as<ThisTypeSubstitution>(targetInterfaceDeclRef.getSubst()));
-
-                                    // We will create a new substitution to apply to the target type.
-                                    ThisTypeSubstitution* newTargetSubst = m_astBuilder->getOrCreateThisTypeSubstitution(
-                                        appThisTypeSubst->interfaceDecl,
-                                        appThisTypeSubst->witness,
-                                        targetInterfaceDeclRef.getSubst());
-
-                                    targetType = DeclRefType::create(m_astBuilder,
-                                        m_astBuilder->getSpecializedDeclRef<InterfaceDecl>(targetInterfaceDeclRef.getDecl(), newTargetSubst));
-
-                                    // Note: we are constructing a this-type substitution that
-                                    // we will apply to the extension declaration as well.
-                                    // This is not strictly allowed by our current representation
-                                    // choices, but we need it in order to make sure that
-                                    // references to the target type of the extension
-                                    // declaration have a chance to resolve the way we want them to.
-
-                                    ThisTypeSubstitution* newExtSubst = m_astBuilder->getOrCreateThisTypeSubstitution(
-                                        appThisTypeSubst->interfaceDecl,
-                                        appThisTypeSubst->witness,
-                                        extDeclRef.getSubst());
-
-                                    extDeclRef = m_astBuilder->getSpecializedDeclRef<ExtensionDecl>(
-                                        extDeclRef.getDecl(),
-                                        newExtSubst);
-
-                                    // TODO: Ideally we should also apply the chosen specialization to
-                                    // the decl-ref for the extension, so that subsequent lookup through
-                                    // the members of this extension will retain that substitution and
-                                    // be able to apply it.
-                                    //
-                                    // E.g., if an extension method returns a value of an associated
-                                    // type, then we'd want that to become specialized to a concrete
-                                    // type when using the extension method on a value of concrete type.
-                                    //
-                                    // The challenge here that makes me reluctant to just staple on
-                                    // such a substitution is that it wouldn't follow our implicit
-                                    // rules about where `ThisTypeSubstitution`s can appear.
-                                }
-                            }
+                            // now let's see if `type`'s declref starts with a Lookup.
+                            targetType = type;
+                            extDeclRef = m_astBuilder->getLookupDeclRef(thisTypeLookupDeclRef->getWitness(), extDeclRef.getDecl());
                         }
                     }
                 }
@@ -6641,7 +6486,6 @@ namespace Slang
         {
             if( auto namespaceDeclRef = declRefExpr->declRef.as<NamespaceDeclBase>() )
             {
-                SLANG_ASSERT(!namespaceDeclRef.getSubst());
                 namespaceDecl = namespaceDeclRef.getDecl();
             }
         }
@@ -7007,7 +6851,7 @@ namespace Slang
                 // the extension to the type and see if we succeed in
                 // making a match.
                 //
-                auto extDeclRef = ApplyExtensionToType(semantics, extDecl, aggType);
+                auto extDeclRef = applyExtensionToType(semantics, extDecl, aggType);
                 if(!extDeclRef)
                     continue;
 
@@ -7065,8 +6909,8 @@ namespace Slang
     {
         if (auto andType = as<AndType>(type))
         {
-            _getCanonicalConstraintTypes(outTypeList, andType->left);
-            _getCanonicalConstraintTypes(outTypeList, andType->right);
+            _getCanonicalConstraintTypes(outTypeList, andType->getLeft());
+            _getCanonicalConstraintTypes(outTypeList, andType->getRight());
         }
         else
         {
@@ -7087,7 +6931,7 @@ namespace Slang
             assert(
                 genericTypeConstraintDecl.getDecl()->sub.type->astNodeType ==
                 ASTNodeType::DeclRefType);
-            auto typeParamDecl = as<DeclRefType>(genericTypeConstraintDecl.getDecl()->sub.type)->declRef.getDecl();
+            auto typeParamDecl = as<DeclRefType>(genericTypeConstraintDecl.getDecl()->sub.type)->getDeclRef().getDecl();
             List<Type*>* constraintTypes = genericConstraints.tryGetValue(typeParamDecl);
             assert(constraintTypes);
             constraintTypes->add(genericTypeConstraintDecl.getDecl()->getSup().type);
@@ -7107,42 +6951,6 @@ namespace Slang
         return result;
     }
 
-    Val* SemanticsDeclTypeResolutionVisitor::resolveVal(Val* val)
-    {
-        if (auto declRefType = as<DeclRefType>(val))
-        {
-            if (auto concreteType = _tryLookupConcreteAssociatedTypeFromThisTypeSubst(m_astBuilder, declRefType->declRef))
-                return as<Type>(concreteType);
-            for (auto subst = declRefType->declRef.getSubst(); subst; subst=subst->getOuter())
-            {
-                if (auto genericSubst = as<GenericSubstitution>(subst))
-                {
-                    ShortList<Val*> newArgs;
-                    for (auto& arg : genericSubst->getArgs())
-                    {
-                        arg = resolveVal(arg);
-                        SLANG_RELEASE_ASSERT(arg);
-                    }
-                }
-            }
-        }
-        else if (auto subtypeWitness = as<SubtypeWitness>(val))
-        {
-            auto sub = as<Type>(resolveVal(subtypeWitness->sub));
-            auto sup = as<Type>(resolveVal(subtypeWitness->sup));
-            if (sub && sup)
-            {
-                if (sub != subtypeWitness->sub || sup != subtypeWitness->sup)
-                {
-                    auto newVal = tryGetSubtypeWitness(as<Type>(sub), as<Type>(sup));
-                    if (newVal)
-                        val = newVal;
-                }
-            }
-        }
-        return val;
-    }
-
     struct ArgsWithDirectionInfo
     {
         List<Expr*> args;
diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp
index 3c90c3ed8..e343e3113 100644
--- a/source/slang/slang-check-expr.cpp
+++ b/source/slang/slang-check-expr.cpp
@@ -22,7 +22,7 @@ namespace Slang
     DeclRefType* SemanticsVisitor::getExprDeclRefType(Expr * expr)
     {
         if (auto typetype = as<TypeType>(expr->type))
-            return dynamicCast<DeclRefType>(typetype->type);
+            return dynamicCast<DeclRefType>(typetype->getType());
         else
             return as<DeclRefType>(expr->type);
     }
@@ -154,10 +154,8 @@ namespace Slang
         //
         return maybeMoveTemp(expr, [&](DeclRef<VarDeclBase> varDeclRef)
         {
-            ExtractExistentialType* openedType = m_astBuilder->create<ExtractExistentialType>();
-            openedType->declRef = varDeclRef;
-            openedType->originalInterfaceType = expr->type.type;
-            openedType->originalInterfaceDeclRef = interfaceDeclRef;
+            ExtractExistentialType* openedType = m_astBuilder->getOrCreate<ExtractExistentialType>(
+                varDeclRef, expr->type.type, interfaceDeclRef);
 
             ExtractExistentialValueExpr* openedValue = m_astBuilder->create<ExtractExistentialValueExpr>();
             openedValue->declRef = varDeclRef;
@@ -202,29 +200,9 @@ namespace Slang
 
         if(auto declRefType = as<DeclRefType>(exprType))
         {
-            if(auto interfaceDeclRef = declRefType->declRef.as<InterfaceDecl>())
+            if(auto interfaceDeclRef = declRefType->getDeclRef().as<InterfaceDecl>())
             {
-                // Is there an this-type substitution being applied, so that
-                // we are referencing the interface type through a concrete
-                // type (e.g., a type parameter constrained to this interface)?
-                //
-                // Because of the way that substitutions need to mirror the nesting
-                // hierarchy of declarations, any this-type substitution pertaining
-                // to the chosen interface decl must be the first substitution on
-                // the list (which is a linked list from the "inside" out).
-                //
-                auto thisTypeSubst = as<ThisTypeSubstitution>(interfaceDeclRef.getSubst());
-                if(thisTypeSubst && thisTypeSubst->interfaceDecl == interfaceDeclRef.getDecl())
-                {
-                    // This isn't really an existential type, because somebody
-                    // has already filled in a this-type substitution.
-                }
-                else
-                {
-                    // Okay, here is the case that matters.
-                    //
-                    return openExistential(expr, interfaceDeclRef);
-                }
+                return openExistential(expr, interfaceDeclRef);
             }
         }
 
@@ -317,7 +295,7 @@ namespace Slang
             // actually names a type, because in that case we are doing
             // a static member reference.
             //
-            if (auto typeType = as<TypeType>(baseExpr->type))
+            if (auto typeType = as<TypeType>(baseExpr->type->getCanonicalType()))
             {
                 // Before forming the reference, we will check if the
                 // member being referenced can even be used as a static
@@ -340,7 +318,7 @@ namespace Slang
                     getSink()->diagnose(
                         loc,
                         Diagnostics::staticRefToNonStaticMember,
-                        typeType->type,
+                        typeType->getType(),
                         declRef.getName());
                 }
 
@@ -493,9 +471,9 @@ namespace Slang
             case LookupResultItem::Breadcrumb::Kind::SuperType:
             {
                 auto witness = as<SubtypeWitness>(breadcrumb->val);
-                if (auto subDeclRefType = as<DeclRefType>(witness->sub))
+                if (auto subDeclRefType = as<DeclRefType>(witness->getSub()))
                 {
-                    if (!as<InterfaceDecl>(subDeclRefType->declRef.getDecl()))
+                    if (!as<InterfaceDecl>(subDeclRefType->getDeclRef().getDecl()))
                     {
                         // Store the inner most concrete super type.
                         subType = subDeclRefType;
@@ -515,10 +493,13 @@ namespace Slang
             return nullptr;
 
         // Don't synthesize for generic parameters.
-        auto parent = as<AggTypeDecl>(subType->declRef.getDecl());
+        auto parent = as<AggTypeDecl>(subType->getDeclRef().getDecl());
         if (!parent)
             return nullptr;
 
+        // Don't synthesize for ThisType.
+        if (as<ThisTypeDecl>(subType->getDeclRef().getDecl()))
+            return nullptr;
 
         // If we reach here, we are expecting a synthesized decl defined in `subType`.
         // Instead of returning a DeclRefExpr to the requirement decl, we synthesize a placeholder decl
@@ -607,7 +588,7 @@ namespace Slang
                         //
                         auto witness = as<SubtypeWitness>(breadcrumb->val);
                         SLANG_ASSERT(witness);
-                        auto expr = createCastToSuperTypeExpr(witness->sup, bb, witness);
+                        auto expr = createCastToSuperTypeExpr(witness->getSup(), bb, witness);
 
                         // Note that we allow a cast of an l-value to
                         // be used as an l-value here because it enables
@@ -926,7 +907,7 @@ namespace Slang
 
         if (auto declRefType = as<DeclRefType>(type))
         {
-            if (auto builtinRequirement = declRefType->declRef.getDecl()->findModifier<BuiltinRequirementModifier>())
+            if (auto builtinRequirement = declRefType->getDeclRef().getDecl()->findModifier<BuiltinRequirementModifier>())
             {
                 if (builtinRequirement->kind == BuiltinRequirementKind::DifferentialType)
                 {
@@ -935,6 +916,7 @@ namespace Slang
                     return type;
                 }
             }
+            type = resolveType(type);
             if (const auto witness = as<SubtypeWitness>(tryGetInterfaceConformanceWitness(type, builder->getDifferentiableInterfaceType())))
             {
                 auto diffTypeLookupResult = lookUpMember(
@@ -964,10 +946,10 @@ namespace Slang
                     auto diffTypeExpr = ConstructLookupResultExpr(
                         diffTypeLookupResult.item,
                         baseTypeExpr,
-                        declRefType->declRef.getLoc(),
+                        declRefType->getDeclRef().getLoc(),
                         baseTypeExpr);
 
-                    return ExtractTypeFromTypeRepr(diffTypeExpr);
+                    return resolveType(ExtractTypeFromTypeRepr(diffTypeExpr));
                 }
             }
         }
@@ -991,7 +973,7 @@ namespace Slang
         SLANG_RELEASE_ASSERT(m_parentDifferentiableAttr);
         if (witness)
         {
-            m_parentDifferentiableAttr->m_mapTypeToIDifferentiableWitness.addIfNotExists(type->declRef, witness);
+            m_parentDifferentiableAttr->addType(type->getDeclRef(), witness);
         }
     }
 
@@ -1048,7 +1030,7 @@ namespace Slang
             {
                 addDifferentiableTypeToDiffTypeRegistry((DeclRefType*)type, subtypeWitness);
             }
-            if (auto aggTypeDeclRef = declRefType->declRef.as<AggTypeDecl>())
+            if (auto aggTypeDeclRef = declRefType->getDeclRef().as<AggTypeDecl>())
             {
                 foreachDirectOrExtensionMemberOfType<InheritanceDecl>(this, aggTypeDeclRef, [&](DeclRef<InheritanceDecl> member)
                     {
@@ -1061,23 +1043,13 @@ namespace Slang
                         maybeRegisterDifferentiableTypeImplRecursive(m_astBuilder, fieldType);
                     });
             }
-            for (auto subst = declRefType->declRef.getSubst(); subst; subst = subst->getOuter())
-            {
-                if (auto genSubst = as<GenericSubstitution>(subst))
+            SubstitutionSet(declRefType->getDeclRef()).forEachSubstitutionArg([&](Val* arg)
                 {
-                    for (auto arg : genSubst->getArgs())
+                    if (auto typeArg = as<Type>(arg))
                     {
-                        if (auto typeArg = as<Type>(arg))
-                        {
-                            maybeRegisterDifferentiableTypeImplRecursive(m_astBuilder, typeArg);
-                        }
+                        maybeRegisterDifferentiableTypeImplRecursive(m_astBuilder, typeArg);
                     }
-                }
-                else if (auto thisSubst = as<ThisTypeSubstitution>(subst))
-                {
-                    maybeRegisterDifferentiableTypeImplRecursive(m_astBuilder, thisSubst->witness->sub);
-                }
-            }
+                });
             return;
         }
     }
@@ -1302,7 +1274,7 @@ namespace Slang
 
             if (auto constArgVal = as<ConstantIntVal>(argVal))
             {
-                constArgVals[a] = constArgVal->value;
+                constArgVals[a] = constArgVal->getValue();
             }
             else
             {
@@ -1366,12 +1338,13 @@ namespace Slang
                 || opName == getName("|") || opName == getName("&") || opName == getName("^") || opName == getName("~") || opName == getName("%") ||
                 opName == getName("?:") || opName == getName("<<") || opName == getName(">>"))
             {
-                auto result = m_astBuilder->create<FuncCallIntVal>(invokeExpr.getExpr()->type.type);
-                result->args.addRange(argVals, argCount);
-                result->funcDeclRef = funcDeclRef;
-                result->funcType = as<Type>(funcDeclRefExpr.getExpr()->type->substitute(
-                    m_astBuilder, funcDeclRefExpr.getSubsts()));
-                SLANG_RELEASE_ASSERT(result->funcType);
+                auto result = m_astBuilder->getOrCreate<FuncCallIntVal>(
+                    invokeExpr.getExpr()->type.type,
+                    funcDeclRef,
+                    as<Type>(funcDeclRefExpr.getExpr()->type->substitute(
+                        m_astBuilder, funcDeclRefExpr.getSubsts())),
+                    makeArrayView(argVals, argCount));
+                SLANG_RELEASE_ASSERT(result->getFuncType());
                 return result;
             }
             return nullptr;
@@ -1507,18 +1480,14 @@ namespace Slang
 
         if (isInterfaceRequirement(decl))
         {
-            for (auto subst = declRef.getSubst(); subst; subst = subst->getOuter())
-            {
-                if (auto thisTypeSubst = as<ThisTypeSubstitution>(subst))
-                {
-                    auto val = WitnessLookupIntVal::tryFold(
-                        m_astBuilder,
-                        thisTypeSubst->witness,
-                        decl,
-                        declRef.substitute(m_astBuilder, decl->type.type));
-                    return as<IntVal>(val);
-                }
-            }
+            auto witness = findThisTypeWitness(SubstitutionSet(declRef), as<InterfaceDecl>(decl->parentDecl));
+
+            auto val = WitnessLookupIntVal::tryFold(
+                m_astBuilder,
+                witness,
+                decl,
+                declRef.substitute(m_astBuilder, decl->type.type));
+            return as<IntVal>(val);
         }
 
         if (!getInitExpr(m_astBuilder, declRef))
@@ -1785,7 +1754,7 @@ namespace Slang
                 getSink()->diagnose(subscriptExpr, Diagnostics::multiDimensionalArrayNotSupported);
             }
 
-            auto elementType = CoerceToUsableType(TypeExp(baseExpr, baseTypeType->type));
+            auto elementType = CoerceToUsableType(TypeExp(baseExpr, baseTypeType->getType()));
             auto arrayType = getArrayType(
                 m_astBuilder,
                 elementType,
@@ -1804,7 +1773,7 @@ namespace Slang
         {
             return CheckSimpleSubscriptExpr(
                 subscriptExpr,
-                vecType->elementType);
+                vecType->getElementType());
         }
         else if (auto matType = as<MatrixExpressionType>(baseType))
         {
@@ -1975,8 +1944,8 @@ namespace Slang
 
         if (basicTypeA && basicTypeB)
         {
-            const auto& infoA = BaseTypeInfo::getInfo(basicTypeA->baseType);
-            const auto& infoB = BaseTypeInfo::getInfo(basicTypeB->baseType);
+            const auto& infoA = BaseTypeInfo::getInfo(basicTypeA->getBaseType());
+            const auto& infoB = BaseTypeInfo::getInfo(basicTypeB->getBaseType());
 
             // TODO(JS): Initially this tries to limit where LValueImplict casts happen.
             // We could in principal allow different sizes, as long as we converted to a temprorary
@@ -2021,7 +1990,7 @@ namespace Slang
             // if this is still an invoke expression, test arguments passed to inout/out parameter are LValues
             if(auto funcType = as<FuncType>(invoke->functionExpr->type))
             {
-                if (!funcType->errorType->equals(m_astBuilder->getBottomType()))
+                if (!funcType->getErrorType()->equals(m_astBuilder->getBottomType()))
                 {
                     // If the callee throws, make sure we are inside a try clause.
                     if (m_enclosingTryClauseType == TryClauseType::None)
@@ -2230,7 +2199,7 @@ namespace Slang
         return result;
     }
 
-    Expr* SemanticsExprVisitor::visitInvokeExpr(InvokeExpr *expr)
+    Expr* SemanticsExprVisitor::visitInvokeExpr(InvokeExpr* expr)
     {
         // check the base expression first
         expr->functionExpr = CheckTerm(expr->functionExpr);
@@ -2312,6 +2281,7 @@ namespace Slang
         auto lookupResult = lookUp(
             m_astBuilder,
             this, expr->name, expr->scope);
+
         if (expr->name == getSession()->getCompletionRequestTokenName())
         {
             auto scopeKind = CompletionSuggestions::ScopeKind::Expr;
@@ -2357,7 +2327,7 @@ namespace Slang
         if (auto modifiedType = as<ModifiedType>(primalType))
         {
             if (modifiedType->findModifier<NoDiffModifierVal>())
-                return modifiedType->base;
+                return modifiedType->getBase();
         }
 
         // Get a reference to the builtin 'IDifferentiable' interface
@@ -2379,23 +2349,23 @@ namespace Slang
         // Resolve JVP type here. 
         // Note that this type checking needs to be in sync with
         // the auto-generation logic in slang-ir-jvp-diff.cpp
-        
-        FuncType* jvpType = m_astBuilder->create<FuncType>();
+        List<Type*> paramTypes;
 
         // The JVP return type is float if primal return type is float
         // void otherwise.
         //
-        jvpType->resultType = getDifferentialPairType(originalType->getResultType());
+        auto resultType = getDifferentialPairType(originalType->getResultType());
         
         // No support for differentiating function that throw errors, for now.
-        SLANG_ASSERT(originalType->errorType->equals(m_astBuilder->getBottomType()));
-        jvpType->errorType = originalType->errorType;
+        SLANG_ASSERT(originalType->getErrorType()->equals(m_astBuilder->getBottomType()));
+        auto errorType = originalType->getErrorType();
 
         for (Index i = 0; i < originalType->getParamCount(); i++)
         {
             if(auto jvpParamType = _toDifferentialParamType(originalType->getParamType(i)))
-                jvpType->paramTypes.add(jvpParamType);
+                paramTypes.add(jvpParamType);
         }
+        FuncType* jvpType = m_astBuilder->getOrCreate<FuncType>(paramTypes.getArrayView(), resultType, errorType);
 
         return jvpType;
     }
@@ -2405,16 +2375,15 @@ namespace Slang
         // Resolve backward diff type here. 
         // Note that this type checking needs to be in sync with
         // the auto-generation logic in slang-ir-jvp-diff.cpp
-
-        FuncType* type = m_astBuilder->create<FuncType>();
+        List<Type*> paramTypes;
 
         // The backward diff return type is void
         //
-        type->resultType = m_astBuilder->getVoidType();
+        auto resultType = m_astBuilder->getVoidType();
 
         // No support for differentiating function that throw errors, for now.
-        SLANG_ASSERT(originalType->errorType->equals(m_astBuilder->getBottomType()));
-        type->errorType = originalType->errorType;
+        SLANG_ASSERT(originalType->getErrorType()->equals(m_astBuilder->getBottomType()));
+        auto errorType = originalType->getErrorType();
 
         for (Index i = 0; i < originalType->getParamCount(); i++)
         {
@@ -2424,7 +2393,7 @@ namespace Slang
                     tryGetDifferentialType(m_astBuilder, outType->getValueType());
                 if (diffElementType)
                 {
-                    type->paramTypes.add(diffElementType);
+                    paramTypes.add(diffElementType);
                 }
                 else
                 {
@@ -2447,16 +2416,16 @@ namespace Slang
                         derivType = inoutType->getValueType();
                     }
                 }
-                type->paramTypes.add(derivType);
+                paramTypes.add(derivType);
             }
         }
         
         // Last parameter is the initial derivative of the original return type
-        auto dOutType = tryGetDifferentialType(m_astBuilder, originalType->resultType);
+        auto dOutType = tryGetDifferentialType(m_astBuilder, originalType->getResultType());
         if (dOutType)
-            type->paramTypes.add(dOutType);
+            paramTypes.add(dOutType);
 
-        return type;
+        return m_astBuilder->getOrCreate<FuncType>(paramTypes.getArrayView(), resultType, errorType);
     }
 
     struct HigherOrderInvokeExprCheckingActions
@@ -2473,9 +2442,8 @@ namespace Slang
                 if (auto baseFuncGenericDeclRef = declRefExpr->declRef.as<GenericDecl>())
                 {
                     // Get inner function
-                    DeclRef<Decl> unspecializedInnerRef = astBuilder->getSpecializedDeclRef<Decl>(
-                        getInner(baseFuncGenericDeclRef),
-                        baseFuncGenericDeclRef.getSubst());
+                    DeclRef<Decl> unspecializedInnerRef = createDefaultSubstitutionsIfNeeded(astBuilder, semantics,
+                        astBuilder->getMemberDeclRef(baseFuncGenericDeclRef, getInner(baseFuncGenericDeclRef)));
                     auto callableDeclRef = unspecializedInnerRef.as<CallableDecl>();
                     if (!callableDeclRef)
                         return nullptr;
@@ -2677,10 +2645,10 @@ namespace Slang
                 return false;
             if (!isIntegerBaseType(getVectorBaseType(vectorType)))
                 return false;
-            auto constElementCount = as<ConstantIntVal>(vectorType->elementCount);
+            auto constElementCount = as<ConstantIntVal>(vectorType->getElementCount());
             if (!constElementCount)
                 return false;
-            return constElementCount->value == 3;
+            return constElementCount->getValue() == 3;
         };
         expr->threadGroupSize = dispatchExpr(expr->threadGroupSize, *this);
         if (!isInt3Type(expr->threadGroupSize->type.type))
@@ -2836,7 +2804,7 @@ namespace Slang
         //
         if( auto declRefType = as<DeclRefType>(typeExp.type) )
         {
-            if(const auto structDeclRef = as<StructDecl>(declRefType->declRef))
+            if(const auto structDeclRef = as<StructDecl>(declRefType->getDeclRef()))
             {
                 if( expr->arguments.getCount() == 1 )
                 {
@@ -3051,7 +3019,7 @@ namespace Slang
             auto baseType = expr->type;
             if (auto pointerLikeType = as<PointerLikeType>(baseType))
             {
-                auto elementType = QualType(pointerLikeType->elementType);
+                auto elementType = QualType(pointerLikeType->getElementType());
                 elementType.isLeftValue = baseType.isLeftValue;
 
                 auto derefExpr = m_astBuilder->create<DerefExpr>();
@@ -3230,7 +3198,7 @@ namespace Slang
             if (auto constantColCount = as<ConstantIntVal>(baseColCount))
             {
                 return CheckMatrixSwizzleExpr(memberRefExpr, baseElementType,
-                    constantRowCount->value, constantColCount->value);
+                    constantRowCount->getValue(), constantColCount->getValue());
             }
         }
         getSink()->diagnose(memberRefExpr, Diagnostics::unimplemented, "swizzle on matrix of unknown size");
@@ -3350,7 +3318,7 @@ namespace Slang
     {
         if (auto constantElementCount = as<ConstantIntVal>(baseElementCount))
         {
-            return CheckSwizzleExpr(memberRefExpr, baseElementType, constantElementCount->value);
+            return CheckSwizzleExpr(memberRefExpr, baseElementType, constantElementCount->getValue());
         }
         else
         {
@@ -3381,6 +3349,7 @@ namespace Slang
                 m_astBuilder,
                 this,
                 expr->name,
+                namespaceDeclRef.getDecl(),
                 namespaceDeclRef);
             if (!lookupResult.isValid())
             {
@@ -3406,7 +3375,7 @@ namespace Slang
             //
             // TODO: this duplicates a *lot* of logic with the case below.
             // We need to fix that.
-            auto type = typeType->type;
+            auto type = typeType->getType();
 
             if (as<ErrorType>(type))
             {
@@ -3577,7 +3546,7 @@ namespace Slang
             for (auto lookupResult : overloadedExpr->lookupResult2)
             {
                 bool shouldRemove = false;
-                if (lookupResult.declRef.getParent(m_astBuilder).as<InterfaceDecl>())
+                if (lookupResult.declRef.getParent().as<InterfaceDecl>())
                 {
                     shouldRemove = true;
                 }
@@ -3627,8 +3596,8 @@ namespace Slang
         {
             return CheckSwizzleExpr(
                 expr,
-                baseVecType->elementType,
-                baseVecType->elementCount);
+                baseVecType->getElementType(),
+                baseVecType->getElementCount());
         }
         else if(auto baseScalarType = as<BasicExpressionType>(baseType))
         {
@@ -3893,7 +3862,7 @@ namespace Slang
         types.reserve(expr->parameters.getCount());
         for(const auto& t : expr->parameters)
             types.add(t.type);
-        auto funcType = m_astBuilder->getFuncType(std::move(types), expr->result.type);
+        auto funcType = m_astBuilder->getFuncType(types.getArrayView(), expr->result.type);
         expr->type = m_astBuilder->getTypeType(funcType);
 
         return expr;
diff --git a/source/slang/slang-check-impl.h b/source/slang/slang-check-impl.h
index 575d4aff7..46cc329a9 100644
--- a/source/slang/slang-check-impl.h
+++ b/source/slang/slang-check-impl.h
@@ -70,7 +70,7 @@ namespace Slang
     {
         if (auto basicType = as<BasicExpressionType>(typeIn))
         {
-            auto rs = makeBasicTypeKey(basicType->baseType);
+            auto rs = makeBasicTypeKey(basicType->getBaseType());
             if (auto constInt = as<IntegerLiteralExpr>(exprIn))
             {
                 if (constInt->value < 0)
@@ -83,11 +83,11 @@ namespace Slang
         }
         else if (auto vectorType = as<VectorExpressionType>(typeIn))
         {
-            if (auto elemCount = as<ConstantIntVal>(vectorType->elementCount))
+            if (auto elemCount = as<ConstantIntVal>(vectorType->getElementCount()))
             {
-                if( auto elemBasicType = as<BasicExpressionType>(vectorType->elementType) )
+                if( auto elemBasicType = as<BasicExpressionType>(vectorType->getElementType()) )
                 {
-                    return makeBasicTypeKey(elemBasicType->baseType, elemCount->value);
+                    return makeBasicTypeKey(elemBasicType->getBaseType(), elemCount->getValue());
                 }
             }
         }
@@ -99,7 +99,7 @@ namespace Slang
                 {
                     if( auto elemBasicType = as<BasicExpressionType>(matrixType->getElementType()) )
                     {
-                        return makeBasicTypeKey(elemBasicType->baseType, elemCount1->value, elemCount2->value);
+                        return makeBasicTypeKey(elemBasicType->getBaseType(), elemCount1->getValue(), elemCount2->getValue());
                     }
                 }
             }
@@ -246,7 +246,7 @@ namespace Slang
         // When required, a candidate can store a pre-checked list of
         // arguments so that we don't have to repeat work across checking
         // phases. Currently this is only needed for generics.
-        Substitutions*   subst = nullptr;
+        SubstitutionSet   subst;
     };
 
     struct TypeCheckingCache
@@ -614,7 +614,7 @@ namespace Slang
         InheritanceInfo getInheritanceInfo(DeclRef<ExtensionDecl> const& extension);
 
             /// Try get subtype witness from cache, returns true if cache contains a result for the query.
-        bool tryGetSubtypeWitness(Type* sub, Type* sup, SubtypeWitness*& outWitness)
+        bool tryGetSubtypeWitnessFromCache(Type* sub, Type* sup, SubtypeWitness*& outWitness)
         {
             auto pair = TypePair{ sub, sup };
             return m_mapTypePairToSubtypeWitness.tryGetValue(pair, outWitness);
@@ -997,6 +997,21 @@ namespace Slang
 
         void diagnoseDeprecatedDeclRefUsage(DeclRef<Decl> declRef, SourceLoc loc, Expr* originalExpr);
 
+        DeclRef<Decl> getDefaultDeclRef(Decl* decl)
+        {
+            return createDefaultSubstitutionsIfNeeded(m_astBuilder, this, makeDeclRef(decl));
+        }
+
+        DeclRef<Decl> getSpecializedDeclRef(DeclRef<Decl> declToSpecialize, DeclRef<Decl> declRefWithSpecializationArgs)
+        {
+            return declRefWithSpecializationArgs.substitute(m_astBuilder, declToSpecialize);
+        }
+
+        DeclRef<Decl> getSpecializedDeclRef(Decl* declToSpecialize, DeclRef<Decl> declRefWithSpecializationArgs)
+        {
+            return declRefWithSpecializationArgs.substitute(m_astBuilder, getDefaultDeclRef(declToSpecialize));
+        }
+
         DeclRefExpr* ConstructDeclRefExpr(
             DeclRef<Decl>   declRef,
             Expr*    baseExpr,
@@ -1026,6 +1041,18 @@ namespace Slang
             SourceLoc loc,
             Expr*    originalExpr);
 
+
+        Val* resolveVal(Val* val)
+        {
+            if (!val) return nullptr;
+            return val->resolve();
+        }
+        Type* resolveType(Type* type)
+        {
+            return (Type*)resolveVal(type);
+        }
+        DeclRef<Decl> resolveDeclRef(DeclRef<Decl> declRef);
+
             /// Attempt to "resolve" an overloaded `LookupResult` to only include the "best" results
         LookupResult resolveOverloadedLookup(LookupResult const& lookupResult);
 
@@ -1651,12 +1678,12 @@ namespace Slang
             List<GenericTypeConstraintDecl*>&   outConstraints);
 
             /// Determine if `left` and `right` have matching generic signatures.
-            /// If they do, then outputs a substitution to `ioSubstRightToLeft` that
-            /// can be used to specialize `right` to the parameters of `left`.
+            /// If they do, then outputs a specialized declRef to `ioSubstRightToLeft` that
+            /// represents a reference to `right` with the parameters of `left`.
         bool doGenericSignaturesMatch(
             GenericDecl*                    left,
             GenericDecl*                    right,
-            GenericSubstitution**    outSubstRightToLeft);
+            DeclRef<Decl>*                  outSpecializedRightInner);
 
         // Check if two functions have the same signature for the purposes
         // of overload resolution.
@@ -1664,9 +1691,6 @@ namespace Slang
             DeclRef<FuncDecl> fst,
             DeclRef<FuncDecl> snd);
 
-        List<Val*> getDefaultSubstitutionArgs(
-            GenericDecl* genericDecl);
-
         Result checkRedeclaration(Decl* newDecl, Decl* oldDecl);
         Result checkFuncRedeclaration(FuncDecl* newDecl, FuncDecl* oldDecl);
         void checkForRedeclaration(Decl* decl);
@@ -1901,12 +1925,13 @@ namespace Slang
         // The `varSubst` argument provides the list of constraint
         // variables that were created for the system.
         //
-        // Returns a new substitution representing the values that
+        // Returns a new declref to the inner decl of `genericDeclRef`,
+        // representing the specialized generic with the values
         // we solved for along the way.
-        SubstitutionSet trySolveConstraintSystem(
+        DeclRef<Decl> trySolveConstraintSystem(
             ConstraintSystem*       system,
             DeclRef<GenericDecl>    genericDeclRef,
-            GenericSubstitution*    substWithKnownGenericArgs = nullptr);
+            ArrayView<Val*> knownGenericArgs);
 
 
         // State related to overload resolution for a call
@@ -2033,7 +2058,7 @@ namespace Slang
         Expr* createGenericDeclRef(
             Expr*            baseExpr,
             Expr*            originalExpr,
-            GenericSubstitution*   subst);
+            SubstitutionSet  substSet);
 
         // Take an overload candidate that previously got through
         // `TryCheckOverloadCandidate` above, and try to finish
@@ -2112,15 +2137,15 @@ namespace Slang
             Val*			fst,
             Val*			snd);
 
-        bool tryUnifySubstitutions(
+        bool tryUnifyDeclRef(
             ConstraintSystem&       constraints,
-            Substitutions*   fst,
-            Substitutions*   snd);
+            DeclRefBase*   fst,
+            DeclRefBase*   snd);
 
-        bool tryUnifyGenericSubstitutions(
-            ConstraintSystem&           constraints,
-            GenericSubstitution* fst,
-            GenericSubstitution* snd);
+        bool tryUnifyGenericAppDeclRef(
+            ConstraintSystem& constraints,
+            GenericAppDeclRef* fst,
+            GenericAppDeclRef* snd);
 
         bool TryUnifyTypeParam(
             ConstraintSystem&				constraints,
@@ -2153,7 +2178,7 @@ namespace Slang
             Type*               snd);
 
         // Is the candidate extension declaration actually applicable to the given type
-        DeclRef<ExtensionDecl> ApplyExtensionToType(
+        DeclRef<ExtensionDecl> applyExtensionToType(
             ExtensionDecl*  extDecl,
             Type*    type);
 
@@ -2166,7 +2191,7 @@ namespace Slang
         DeclRef<Decl> inferGenericArguments(
             DeclRef<GenericDecl>    genericDeclRef,
             OverloadResolveContext& context,
-            GenericSubstitution*    substWithKnownGenericArgs,
+            ArrayView<Val*>         knownGenericArgs,
             List<Type*>             *innerParameterTypes = nullptr);
 
         void AddTypeOverloadCandidates(
@@ -2209,7 +2234,7 @@ namespace Slang
         void addOverloadCandidatesForCallToGeneric(
             LookupResultItem        genericItem,
             OverloadResolveContext& context,
-            GenericSubstitution*    substWithKnownGenericArgs = nullptr);
+            ArrayView<Val*>     knownGenericArgs);
 
             /// Check a generic application where the operands have already been checked.
         Expr* checkGenericAppWithCheckedArgs(GenericAppExpr* genericAppExpr);
@@ -2283,7 +2308,7 @@ namespace Slang
         visitor->ensureDecl(decl, state);
     }
 
-    DeclRef<ExtensionDecl> ApplyExtensionToType(
+    DeclRef<ExtensionDecl> applyExtensionToType(
         SemanticsVisitor*   semantics,
         ExtensionDecl*      extDecl,
         Type*               type);
@@ -2318,8 +2343,6 @@ namespace Slang
 
         Expr* visitSharedTypeExpr(SharedTypeExpr* expr);
 
-        Expr* visitTaggedUnionTypeExpr(TaggedUnionTypeExpr* expr);
-
         Expr* visitInvokeExpr(InvokeExpr *expr);
 
         Expr* visitSelectExpr(SelectExpr* expr);
diff --git a/source/slang/slang-check-inheritance.cpp b/source/slang/slang-check-inheritance.cpp
index 5a6adbae5..5fff47cf1 100644
--- a/source/slang/slang-check-inheritance.cpp
+++ b/source/slang/slang-check-inheritance.cpp
@@ -220,7 +220,7 @@ namespace Slang
             DeclRef<Decl> baseDeclRef;
             if (auto baseDeclRefType = as<DeclRefType>(baseType))
             {
-                baseDeclRef = baseDeclRefType->declRef;
+                baseDeclRef = baseDeclRefType->getDeclRef();
             }
 
             addDirectBaseFacet(
@@ -239,9 +239,9 @@ namespace Slang
             // In the case where we have an aggregate type or `extension`
             // declaration, we can use the explicit list of direct bases.
             //
-            for (auto inheritanceDeclRef : getMembersOfType<InheritanceDecl>(_getASTBuilder(), aggTypeDeclBaseRef))
+            for (auto typeConstraintDeclRef : getMembersOfType<TypeConstraintDecl>(_getASTBuilder(), aggTypeDeclBaseRef))
             {
-                visitor.ensureDecl(inheritanceDeclRef, DeclCheckState::CanUseBaseOfInheritanceDecl);
+                visitor.ensureDecl(typeConstraintDeclRef, DeclCheckState::CanUseBaseOfInheritanceDecl);
 
                 // Note: In certain cases something takes the *syntactic* form of an inheritance
                 // clause, but it is not actually something that should be treated as implying
@@ -251,38 +251,20 @@ namespace Slang
                 // We skip such pseudo-inheritance relationships for the purposes of determining
                 // the linearized list of bases.
                 //
-                if (inheritanceDeclRef.getDecl()->hasModifier<IgnoreForLookupModifier>())
+                if (typeConstraintDeclRef.getDecl()->hasModifier<IgnoreForLookupModifier>())
                     continue;
 
                 // The base type and subtype witness can easily be determined
                 // using the `InheritanceDecl`.
                 //
-                auto baseType = getSup(astBuilder, inheritanceDeclRef);
+                auto baseType = getSup(astBuilder, typeConstraintDeclRef);
                 auto satisfyingWitness = astBuilder->getDeclaredSubtypeWitness(
                     selfType,
                     baseType,
-                    inheritanceDeclRef);
+                    typeConstraintDeclRef);
 
                 addDirectBaseType(baseType, satisfyingWitness);
             }
-
-            // In the case of an `associatedtype`, the constraints on the associated
-            // type are encoded as `GenericTypeConstraintDecl`s instead of `InheritanceDecl`s.
-            //
-            // TOD(tfoley): Can we try to unify the representations of these to avoid having
-            // to iterate twice?
-            //
-            for (auto constraintDeclRef : getMembersOfType<GenericTypeConstraintDecl>(astBuilder, aggTypeDeclBaseRef))
-            {
-                visitor.ensureDecl(constraintDeclRef, DeclCheckState::CanUseBaseOfInheritanceDecl);
-
-                auto baseType = getSup(astBuilder, constraintDeclRef);
-                auto satisfyingWitness = astBuilder->getDeclaredSubtypeWitness(
-                    selfType,
-                    baseType,
-                    constraintDeclRef);
-                addDirectBaseType(baseType, satisfyingWitness);
-            }
         }
         else if (auto genericTypeParamDeclRef = declRef.as<GenericTypeParamDecl>())
         {
@@ -296,7 +278,7 @@ namespace Slang
             // representation would need to take into account canonicalization of
             // constraints.
 
-            auto genericDeclRef = genericTypeParamDeclRef.getParent(astBuilder).as<GenericDecl>();
+            auto genericDeclRef = genericTypeParamDeclRef.getParent().as<GenericDecl>();
             SLANG_ASSERT(genericDeclRef);
 
             ensureDecl(&visitor, genericDeclRef.getDecl(), DeclCheckState::CanSpecializeGeneric);
@@ -317,7 +299,7 @@ namespace Slang
                 auto subDeclRefType = as<DeclRefType>(subType);
                 if (!subDeclRefType)
                     continue;
-                if (subDeclRefType->declRef != genericTypeParamDeclRef)
+                if (subDeclRefType->getDeclRef() != genericTypeParamDeclRef)
                     continue;
 
                 // Because the constraint is a declared inheritance relationship,
@@ -376,7 +358,7 @@ namespace Slang
                 // the extension to the type and see if we succeed in
                 // making a match.
                 //
-                auto extDeclRef = ApplyExtensionToType(&visitor, extDecl, selfType);
+                auto extDeclRef = applyExtensionToType(&visitor, extDecl, selfType);
                 if (!extDeclRef)
                     continue;
 
@@ -858,15 +840,15 @@ namespace Slang
             // bottleneck through the logic that gets shared between
             // type and `extension` declarations.
             //
-            return _getInheritanceInfo(declRefType->declRef, declRefType);
+            return _getInheritanceInfo(declRefType->getDeclRef(), declRefType);
         }
         else if (auto conjunctionType = as<AndType>(type))
         {
             // In this case, we have a type of the form `L & R`,
             // such that it is a subtype of both `L` and `R`.
             //
-            auto leftType = conjunctionType->left;
-            auto rightType = conjunctionType->right;
+            auto leftType = conjunctionType->getLeft();
+            auto rightType = conjunctionType->getRight();
 
             // The linearized inheritance list for the conjunction
             // must include all the facets from the lists for `L`
diff --git a/source/slang/slang-check-modifier.cpp b/source/slang/slang-check-modifier.cpp
index ce80d0002..ab34c83dd 100644
--- a/source/slang/slang-check-modifier.cpp
+++ b/source/slang/slang-check-modifier.cpp
@@ -310,12 +310,12 @@ namespace Slang
                     {
                         return false;
                     }
-                    if (intValue->value < 1)
+                    if (intValue->getValue() < 1)
                     {
-                        getSink()->diagnose(attr, Diagnostics::nonPositiveNumThreads, intValue->value);
+                        getSink()->diagnose(attr, Diagnostics::nonPositiveNumThreads, intValue->getValue());
                         return false;
                     }
-                    value = int32_t(intValue->value);
+                    value = int32_t(intValue->getValue());
                 }
                 values[i] = value;
             }
@@ -341,13 +341,13 @@ namespace Slang
             }
 
             const IRIntegerValue kMaxAnyValueSize = 0x7FFF;
-            if (value->value > kMaxAnyValueSize)
+            if (value->getValue() > kMaxAnyValueSize)
             {
                 getSink()->diagnose(anyValueSizeAttr->loc, Diagnostics::anyValueSizeExceedsLimit, kMaxAnyValueSize);
                 return false;
             }
 
-            anyValueSizeAttr->size = int32_t(value->value);
+            anyValueSizeAttr->size = int32_t(value->getValue());
         }
         else if (auto bindingAttr = as<GLSLBindingAttribute>(attr))
         {
@@ -369,8 +369,8 @@ namespace Slang
                 return false;
             }
 
-            bindingAttr->binding = int32_t(binding->value);
-            bindingAttr->set = int32_t(set->value);
+            bindingAttr->binding = int32_t(binding->getValue());
+            bindingAttr->set = int32_t(set->getValue());
         }
         else if (auto simpleLayoutAttr = as<GLSLSimpleIntegerLayoutAttribute>(attr))
         {
@@ -388,7 +388,7 @@ namespace Slang
                 return false;
             }
 
-            simpleLayoutAttr->value = int32_t(value->value);
+            simpleLayoutAttr->value = int32_t(value->getValue());
         }
         else if (auto maxVertexCountAttr = as<MaxVertexCountAttribute>(attr))
         {
@@ -397,7 +397,7 @@ namespace Slang
 
             if (!val) return false;
 
-            maxVertexCountAttr->value = (int32_t)val->value;
+            maxVertexCountAttr->value = (int32_t)val->getValue();
         }
         else if (auto instanceAttr = as<InstanceAttribute>(attr))
         {
@@ -406,7 +406,7 @@ namespace Slang
 
             if (!val) return false;
 
-            instanceAttr->value = (int32_t)val->value;
+            instanceAttr->value = (int32_t)val->getValue();
         }
         else if (auto entryPointAttr = as<EntryPointAttribute>(attr))
         {
@@ -486,7 +486,7 @@ namespace Slang
                 //IntVal* outIntVal;
                 if (auto cInt = checkConstantEnumVal(attr->args[0]))
                 {
-                    targetClassId = (uint32_t)(cInt->value);
+                    targetClassId = (uint32_t)(cInt->getValue());
                 }
                 else
                 {
@@ -515,7 +515,7 @@ namespace Slang
             }
             auto cint = checkConstantIntVal(attr->args[0]);
             if (cint)
-                forceUnrollAttr->maxIterations = (int32_t)cint->value;
+                forceUnrollAttr->maxIterations = (int32_t)cint->getValue();
         }
         else if (auto maxItersAttrs = as<MaxItersAttribute>(attr))
         {
@@ -528,7 +528,7 @@ namespace Slang
                 auto cint = checkConstantIntVal(attr->args[0]);
                 if (cint)
                 {
-                    maxItersAttrs->value = (int32_t) cint->value;
+                    maxItersAttrs->value = (int32_t) cint->getValue();
                 }
             }
         }
@@ -547,10 +547,12 @@ namespace Slang
                     bool typeChecked = false;
                     if (auto basicType = as<BasicExpressionType>(paramDecl->getType()))
                     {
-                        if (basicType->baseType == BaseType::Int)
+                        if (basicType->getBaseType() == BaseType::Int)
                         {
                             if (auto cint = checkConstantIntVal(arg))
                             {
+                                for (Index ci = attr->intArgVals.getCount(); ci < paramIndex + 1; ci++)
+                                    attr->intArgVals.add(nullptr);
                                 attr->intArgVals[(uint32_t)paramIndex] = cint;
                             }
                             typeChecked = true;
@@ -578,7 +580,7 @@ namespace Slang
             SLANG_ASSERT(attr->args.getCount() == 1);
             auto cint = checkConstantIntVal(attr->args[0]);
             if (cint)
-                diffAttr->maxOrder = (int32_t)cint->value;
+                diffAttr->maxOrder = (int32_t)cint->getValue();
         }
         else if (auto formatAttr = as<FormatAttribute>(attr))
         {
@@ -652,7 +654,7 @@ namespace Slang
 
             if (!val) return false;
 
-            rayPayloadAttr->location = (int32_t)val->value;
+            rayPayloadAttr->location = (int32_t)val->getValue();
         }
         else if (auto callablePayloadAttr = as<VulkanCallablePayloadAttribute>(attr))
         {
@@ -661,7 +663,7 @@ namespace Slang
 
             if (!val) return false;
 
-            callablePayloadAttr->location = (int32_t)val->value;
+            callablePayloadAttr->location = (int32_t)val->getValue();
         }
         else if (auto hitObjectAttributesAttr = as<VulkanHitObjectAttributesAttribute>(attr))
         {
@@ -670,7 +672,7 @@ namespace Slang
 
             if (!val) return false;
 
-            hitObjectAttributesAttr->location = (int32_t)val->value;
+            hitObjectAttributesAttr->location = (int32_t)val->getValue();
         }
         else if (as<UserDefinedDerivativeAttribute>(attr) || as<PrimalSubstituteAttribute>(attr))
         {
diff --git a/source/slang/slang-check-overload.cpp b/source/slang/slang-check-overload.cpp
index 2fa13f3fa..8709ae763 100644
--- a/source/slang/slang-check-overload.cpp
+++ b/source/slang/slang-check-overload.cpp
@@ -70,7 +70,7 @@ namespace Slang
         {
             if (auto resultType = as<DeclRefType>(candidate.resultType))
             {
-                if (resultType->declRef.as<ClassDecl>())
+                if (resultType->getDeclRef().as<ClassDecl>())
                 {
                     isClassType = true;
                 }
@@ -373,7 +373,7 @@ namespace Slang
                 //
                 if( !val )
                 {
-                    val = m_astBuilder->create<ErrorIntVal>();
+                    val = m_astBuilder->getOrCreate<ErrorIntVal>(m_astBuilder->getIntType());
                 }
                 checkedArgs.add(val);
             }
@@ -383,8 +383,8 @@ namespace Slang
             }
         }
 
-        auto genSubst = m_astBuilder->getOrCreateGenericSubstitution(nullptr, genericDeclRef.getDecl(), checkedArgs.getArrayView());
-        candidate.subst = genSubst;
+        auto genSubst = m_astBuilder->getGenericAppDeclRef(genericDeclRef, checkedArgs.getArrayView());
+        candidate.subst = SubstitutionSet(genSubst);
 
         // Once we are done processing the parameters of the generic,
         // we will have build up a usable `checkedArgs` array and
@@ -550,19 +550,17 @@ namespace Slang
 
         // We should have the existing arguments to the generic
         // handy, so that we can construct a substitution list.
-        auto subst = as<GenericSubstitution>(candidate.subst);
-        SLANG_ASSERT(subst);
+        auto substArgs = tryGetGenericArguments(candidate.subst, genericDeclRef.getDecl());
+        SLANG_ASSERT(substArgs.getCount());
 
-        subst = getASTBuilder()->getOrCreateGenericSubstitution(
-            genericDeclRef.getSubst(), genericDeclRef.getDecl(), subst->getArgs());
-
-        List<Val*> newArgs = subst->getArgs();
+        List<Val*> newArgs;
+        for (auto arg : substArgs)
+            newArgs.add(arg);
 
         for( auto constraintDecl : genericDeclRef.getDecl()->getMembersOfType<GenericTypeConstraintDecl>() )
         {
-            DeclRef<GenericTypeConstraintDecl> constraintDeclRef = m_astBuilder->getSpecializedDeclRef(
-                constraintDecl, subst);
-
+            DeclRef<GenericTypeConstraintDecl> constraintDeclRef = m_astBuilder->getGenericAppDeclRef(genericDeclRef, substArgs, constraintDecl).as<GenericTypeConstraintDecl>();
+            
             auto sub = getSub(m_astBuilder, constraintDeclRef);
             auto sup = getSup(m_astBuilder, constraintDeclRef);
 
@@ -575,14 +573,14 @@ namespace Slang
             {
                 if(context.mode != OverloadResolveContext::Mode::JustTrying)
                 {
-                    subTypeWitness = tryGetSubtypeWitness(sub, sup);
+                    subTypeWitness = isSubtype(sub, sup);
                     getSink()->diagnose(context.loc, Diagnostics::typeArgumentDoesNotConformToInterface, sub, sup);
                 }
                 return false;
             }
         }
 
-        candidate.subst = m_astBuilder->getOrCreateGenericSubstitution(nullptr, genericDeclRef.getDecl(), newArgs);
+        candidate.subst = SubstitutionSet(m_astBuilder->getGenericAppDeclRef(genericDeclRef, newArgs.getArrayView()));
 
         // Done checking all the constraints, hooray.
         return true;
@@ -617,7 +615,7 @@ namespace Slang
     Expr* SemanticsVisitor::createGenericDeclRef(
         Expr*                baseExpr,
         Expr*                originalExpr,
-        GenericSubstitution* subst)
+        SubstitutionSet      substArgs)
     {
         auto baseDeclRefExpr = as<DeclRefExpr>(baseExpr);
         if (!baseDeclRefExpr)
@@ -631,10 +629,9 @@ namespace Slang
             SLANG_DIAGNOSE_UNEXPECTED(getSink(), baseExpr, "expected a reference to a generic declaration");
             return CreateErrorExpr(originalExpr);
         }
-
-        subst = m_astBuilder->getOrCreateGenericSubstitution(baseGenericRef.getSubst(), baseGenericRef.getDecl(), subst->getArgs());
-
-        DeclRef<Decl> innerDeclRef = m_astBuilder->getSpecializedDeclRef<Decl>(getInner(baseGenericRef), subst);
+        auto genSubst = substArgs.findGenericAppDeclRef(baseGenericRef.getDecl());
+        SLANG_ASSERT(genSubst);
+        DeclRef<Decl> innerDeclRef = m_astBuilder->getGenericAppDeclRef(baseGenericRef, genSubst->getArgs());
 
         Expr* base = nullptr;
         if (auto mbrExpr = as<MemberExpr>(baseExpr))
@@ -768,14 +765,16 @@ namespace Slang
                     expr->loc = context.loc;
                     expr->originalExpr = baseExpr;
                     expr->baseGenericDeclRef = as<DeclRefExpr>(baseExpr)->declRef.as<GenericDecl>();
-                    expr->substWithKnownGenericArgs = (GenericSubstitution*)candidate.subst;
+                    auto args = tryGetGenericArguments(candidate.subst, expr->baseGenericDeclRef.getDecl());
+                    for (auto arg : args)
+                        expr->knownGenericArgs.add(arg);
                     return expr;
                 }
 
                 return createGenericDeclRef(
                     baseExpr,
                     context.originalExpr,
-                    as<GenericSubstitution>(candidate.subst));
+                    candidate.subst);
                 break;
 
             default:
@@ -801,12 +800,14 @@ namespace Slang
         /// Does the given `declRef` represent an interface requirement?
     bool isInterfaceRequirement(ASTBuilder* builder, DeclRef<Decl> const& declRef)
     {
+        SLANG_UNUSED(builder);
+
         if(!declRef)
             return false;
 
-        auto parent = declRef.getParent(builder);
+        auto parent = declRef.getParent();
         if(parent.as<GenericDecl>())
-            parent = parent.getParent(builder);
+            parent = parent.getParent();
 
         if(parent.as<InterfaceDecl>())
             return true;
@@ -826,7 +827,7 @@ namespace Slang
         // "inner" declaration of a generic. That means that
         // the parent of the decl ref must be a generic.
         //
-        auto parentGeneric = declRef.getParent(m_astBuilder).as<GenericDecl>();
+        auto parentGeneric = declRef.getParent().as<GenericDecl>();
         if(!parentGeneric)
             return 0;
         //
@@ -863,7 +864,18 @@ namespace Slang
         if(leftIsInterfaceRequirement != rightIsInterfaceRequirement)
             return int(leftIsInterfaceRequirement) - int(rightIsInterfaceRequirement);
 
-        // TODO: We should always have rules such that in a tie a declaration
+        // If both are interface requirements, prefer to more derived interface.
+        if (leftIsInterfaceRequirement && rightIsInterfaceRequirement)
+        {
+            auto leftType = DeclRefType::create(m_astBuilder, left.declRef.getParent());
+            auto rightType = DeclRefType::create(m_astBuilder, right.declRef.getParent());
+            if (isSubtype(leftType, rightType))
+                return -1;
+            if (isSubtype(rightType, leftType))
+                return 1;
+        }
+
+        // TODO: We should generalize above rules such that in a tie a declaration
         // A::m is better than B::m when all other factors are equal and
         // A inherits from B.
 
@@ -1227,7 +1239,7 @@ namespace Slang
     DeclRef<Decl> SemanticsVisitor::inferGenericArguments(
         DeclRef<GenericDecl>    genericDeclRef,
         OverloadResolveContext& context,
-        GenericSubstitution*    substWithKnownGenericArgs,
+        ArrayView<Val*>         knownGenericArgs,
         List<Type*>             *innerParameterTypes)
     {
         // We have been asked to infer zero or more arguments to
@@ -1265,28 +1277,10 @@ namespace Slang
         // the "inner" declaration of the generic (e.g., the `FuncitonDecl`
         // under the `GenericDecl`).
         //
-        // In the case where no explicit arguments are available, we will
-        // use any substitutions that were in place for referring to the
-        // generic itself.
-        //
-        Substitutions* substForInnerDecl = genericDeclRef.getSubst();
-        //
-        // In the case where we have explicit/known arguments,
-        // we will use those as our baseline substitutions.
-        //
-        if (substWithKnownGenericArgs)
-        {
-            substForInnerDecl = substWithKnownGenericArgs;
-        }
-
-        auto innerDecl = getInner(genericDeclRef);
-        DeclRef<Decl> partiallySpecializedInnerRef = m_astBuilder->getSpecializedDeclRef<Decl>(
-            innerDecl,
-            substForInnerDecl);
-
         // Check what type of declaration we are dealing with, and then try
         // to match it up with the arguments accordingly...
-        if (auto funcDeclRef = partiallySpecializedInnerRef.as<CallableDecl>())
+
+        if (auto funcDeclRef = as<CallableDecl>(genericDeclRef.getDecl()->inner))
         {
             List<Type*> paramTypes;
             if (!innerParameterTypes)
@@ -1360,28 +1354,8 @@ namespace Slang
         // TODO(tfoley): We probably need to pass along the explicit arguments here,
         // so that the solver knows to accept those arguments as-is.
         //
-        auto constraintSubst = trySolveConstraintSystem(
-            &constraints, genericDeclRef, substWithKnownGenericArgs);
-        if (!constraintSubst)
-        {
-            // In this case, the solver failed to find a solution to the constraint
-            // system, and we will signal that failure up to the client that called
-            // this operation.
-            //
-            // TODO: We really ought to be passing up some kind of representation
-            // of the failure, so that constraint-related issues can be reported to
-            // the user. This could either be a return path here (returning some
-            // diagnostics), or this code could have a "just trying" vs. "actually
-            // do things" distinction like some other steps.
-            //
-            return DeclRef<Decl>();
-        }
-
-        // If we found a solution (that is, a set of argument values that satisfy
-        // all the constraints), we can construct a reference to the inner
-        // declaration that applies the generic to those arguments.
-        //
-        return m_astBuilder->getSpecializedDeclRef<Decl>(innerDecl, constraintSubst);
+        return trySolveConstraintSystem(
+            &constraints, genericDeclRef, knownGenericArgs);
     }
 
     void SemanticsVisitor::AddTypeOverloadCandidates(
@@ -1424,13 +1398,13 @@ namespace Slang
     void SemanticsVisitor::addOverloadCandidatesForCallToGeneric(
         LookupResultItem                genericItem,
         OverloadResolveContext&         context,
-        GenericSubstitution*            substWithKnownGenericArgs)
+        ArrayView<Val*>                 knownGenericArgs)
     {
         auto genericDeclRef = genericItem.declRef.as<GenericDecl>();
         SLANG_ASSERT(genericDeclRef);
 
         // Try to infer generic arguments, based on the context
-        DeclRef<Decl> innerRef = inferGenericArguments(genericDeclRef, context, substWithKnownGenericArgs);
+        DeclRef<Decl> innerRef = inferGenericArguments(genericDeclRef, context, knownGenericArgs);
 
         if (innerRef)
         {
@@ -1475,7 +1449,7 @@ namespace Slang
             LookupResultItem innerItem;
             innerItem.breadcrumbs = item.breadcrumbs;
             innerItem.declRef = genericDeclRef;
-            addOverloadCandidatesForCallToGeneric(innerItem, context);
+            addOverloadCandidatesForCallToGeneric(innerItem, context, ArrayView<Val*>());
         }
         else if( auto typeDefDeclRef = item.declRef.as<TypeDefDecl>() )
         {
@@ -1578,7 +1552,7 @@ namespace Slang
             addOverloadCandidatesForCallToGeneric(
                 LookupResultItem(partiallyAppliedGenericExpr->baseGenericDeclRef),
                 context,
-                partiallyAppliedGenericExpr->substWithKnownGenericArgs);
+                partiallyAppliedGenericExpr->knownGenericArgs.getArrayView());
         }
         else if (auto typeType = as<TypeType>(funcExprType))
         {
@@ -1588,7 +1562,7 @@ namespace Slang
             //
             // TODO(tfoley): are there any meaningful types left
             // that aren't declaration references?
-            auto type = typeType->type;
+            auto type = typeType->getType();
             AddTypeOverloadCandidates(type, context);
             return;
         }
@@ -1633,12 +1607,16 @@ namespace Slang
                     paramTypes.add(removeParamDirType(diffFuncType->getParamType(ii)));
 
                 // Try to infer generic arguments, based on the updated context.
+                OverloadResolveContext subContext = context;
                 DeclRef<Decl> innerRef = inferGenericArguments(
                     baseFuncGenericDeclRef,
                     context,
-                    nullptr,
+                    ArrayView<Val*>(),
                     &paramTypes);
 
+                if (!innerRef)
+                    return;
+
                 OverloadCandidate candidate;
                 candidate.flavor = OverloadCandidate::Flavor::Expr;
                 if (innerRef)
diff --git a/source/slang/slang-check-resolve-val.cpp b/source/slang/slang-check-resolve-val.cpp
new file mode 100644
index 000000000..91722f82c
--- /dev/null
+++ b/source/slang/slang-check-resolve-val.cpp
@@ -0,0 +1,48 @@
+// slang-check-resolve-val.cpp
+
+// Logic for resolving/simplifying Types and DeclRefs.
+
+#include "slang-check-impl.h"
+
+#include "slang-lookup.h"
+#include "slang-syntax.h"
+#include "slang-ast-synthesis.h"
+#include "slang-ast-reflect.h"
+
+namespace Slang
+{
+
+Type* Type::createCanonicalType()
+{
+    SLANG_AST_NODE_VIRTUAL_CALL(Type, createCanonicalType, ());
+}
+
+Val* Type::_resolveImplOverride()
+{
+    Val* resolvedVal = createCanonicalType();
+    return resolvedVal;
+}
+
+DeclRefBase* _resolveAsDeclRef(DeclRefBase* declRefToResolve);
+
+Type* DeclRefType::_createCanonicalTypeOverride()
+{
+    auto astBuilder = getCurrentASTBuilder();
+
+    // A declaration reference is already canonical
+    auto resolvedDeclRef = getDeclRef();
+    resolvedDeclRef = _resolveAsDeclRef(getDeclRef().declRefBase);
+    if (auto satisfyingVal = _tryLookupConcreteAssociatedTypeFromThisTypeSubst(astBuilder, resolvedDeclRef))
+        return as<Type>(satisfyingVal);
+    if (resolvedDeclRef != getDeclRef())
+        return DeclRefType::create(astBuilder, resolvedDeclRef);
+    return this;
+}
+
+
+Val* SubtypeWitness::_resolveImplOverride()
+{
+    return as<SubtypeWitness>(defaultResolveImpl());
+}
+
+}
diff --git a/source/slang/slang-check-shader.cpp b/source/slang/slang-check-shader.cpp
index 657438222..d9bb11548 100644
--- a/source/slang/slang-check-shader.cpp
+++ b/source/slang/slang-check-shader.cpp
@@ -17,7 +17,7 @@ namespace Slang
             auto basicType = as<BasicExpressionType>(type);
             if (basicType)
             {
-                return (basicType->baseType == BaseType::Int || basicType->baseType == BaseType::UInt);
+                return (basicType->getBaseType() == BaseType::Int || basicType->getBaseType() == BaseType::UInt);
             }
         }
         // Can be an int/uint vector from size 1 to 3
@@ -27,20 +27,21 @@ namespace Slang
             {
                 return false;
             }
-            auto elemCount = as<ConstantIntVal>(vectorType->elementCount);
-            if (elemCount->value < 1 || elemCount->value > 3)
+            auto elemCount = as<ConstantIntVal>(vectorType->getElementCount());
+            if (elemCount->getValue() < 1 || elemCount->getValue() > 3)
             {
                 return false;
             }
             // Must be a basic type
-            auto basicType = as<BasicExpressionType>(vectorType->elementType);
+            auto basicType = as<BasicExpressionType>(vectorType->getElementType());
             if (!basicType)
             {
                 return false;
             }
 
             // Must be integral
-            return (basicType->baseType == BaseType::Int || basicType->baseType == BaseType::UInt);
+            auto baseType = basicType->getBaseType();
+            return (baseType == BaseType::Int || baseType == BaseType::UInt);
         }
     }
 
@@ -83,7 +84,7 @@ namespace Slang
 
         if( auto declRefType = as<DeclRefType>(type) )
         {
-            auto typeDeclRef = declRefType->declRef;
+            auto typeDeclRef = declRefType->getDeclRef();
             if( auto interfaceDeclRef = typeDeclRef.as<InterfaceDecl>() )
             {
                 // Each leaf parameter of interface type adds a specialization
@@ -792,6 +793,8 @@ namespace Slang
     void FrontEndCompileRequest::checkEntryPoints()
     {
         auto linkage = getLinkage();
+        SLANG_AST_BUILDER_RAII(linkage->getASTBuilder());
+
         auto sink = getSink();
 
         // The validation of entry points here will be modal, and controlled
@@ -1025,7 +1028,7 @@ namespace Slang
                     //
                     if( auto argDeclRefType = as<DeclRefType>(argType) )
                     {
-                        auto argDeclRef = argDeclRefType->declRef;
+                        auto argDeclRef = argDeclRefType->getDeclRef();
                         if(auto argGenericParamDeclRef = argDeclRef.as<GlobalGenericParamDecl>())
                         {
                             if(argGenericParamDeclRef.getDecl() == genericTypeParamDecl)
@@ -1193,7 +1196,7 @@ namespace Slang
             // the semantic checking machinery to expand out
             // the rest of the arguments via inference...
 
-            auto genericDeclRef = m_funcDeclRef.getParent(getLinkage()->getASTBuilder()).as<GenericDecl>();
+            auto genericDeclRef = m_funcDeclRef.getParent().as<GenericDecl>();
             SLANG_ASSERT(genericDeclRef); // otherwise we wouldn't have generic parameters
 
             List<Val*> genericArgs;
@@ -1203,19 +1206,13 @@ namespace Slang
                 auto specializationArg = args[ii];
                 genericArgs.add(specializationArg.val);
             }
-            GenericSubstitution* genericSubst =
-                getLinkage()->getASTBuilder()->getOrCreateGenericSubstitution(
-                    genericDeclRef.getSubst(),
-                    genericDeclRef.getDecl(),
-                    genericArgs.getArrayView());
+            auto genericInnerDeclRef = getLinkage()->getASTBuilder()->getGenericAppDeclRef(genericDeclRef, genericArgs.getArrayView());
             ASTBuilder* astBuilder = getLinkage()->getASTBuilder();
 
             for (auto constraintDecl : getMembersOfType<GenericTypeConstraintDecl>(
                      getLinkage()->getASTBuilder(), DeclRef<ContainerDecl>(genericDeclRef)))
             {
-                DeclRef<GenericTypeConstraintDecl> constraintDeclRef = astBuilder->getSpecializedDeclRef(
-                    constraintDecl.getDecl(), genericSubst);
-
+                DeclRef<GenericTypeConstraintDecl> constraintDeclRef = astBuilder->getDirectDeclRef(constraintDecl.getDecl());
 
                 auto sub = getSub(astBuilder, constraintDeclRef);
                 auto sup = getSup(astBuilder, constraintDeclRef);
@@ -1233,12 +1230,8 @@ namespace Slang
                 }
             }
 
-            genericSubst =
-                getLinkage()->getASTBuilder()->getOrCreateGenericSubstitution(
-                    genericDeclRef.getSubst(),
-                    genericDeclRef.getDecl(),
-                    genericArgs);
-            specializedFuncDeclRef = astBuilder->getSpecializedDeclRef(specializedFuncDeclRef.getDecl(), genericSubst);
+            specializedFuncDeclRef = getLinkage()->getASTBuilder()->getGenericAppDeclRef(genericDeclRef, genericArgs.getArrayView()).as<FuncDecl>();
+            SLANG_ASSERT(specializedFuncDeclRef);
         }
 
         info->specializedFuncDeclRef = specializedFuncDeclRef;
@@ -1418,9 +1411,8 @@ namespace Slang
             specializationArgs.add(arg);
         }
 
-        ExistentialSpecializedType* specializedType = m_astBuilder->create<ExistentialSpecializedType>();
-        specializedType->baseType = unspecializedType;
-        specializedType->args = specializationArgs;
+        ExistentialSpecializedType* specializedType = m_astBuilder->getOrCreate<ExistentialSpecializedType>(
+            unspecializedType, specializationArgs);
 
         m_specializedTypes.add(specializedType);
 
diff --git a/source/slang/slang-check-stmt.cpp b/source/slang/slang-check-stmt.cpp
index ba7e977e3..4b4257f75 100644
--- a/source/slang/slang-check-stmt.cpp
+++ b/source/slang/slang-check-stmt.cpp
@@ -526,7 +526,7 @@ namespace Slang
         }
         if (!stepSize)
             return;
-        if (stepSize->value > 0)
+        if (stepSize->getValue() > 0)
         {
             if (sideEffectFuncOp == kIROp_Add && compareOp == kIROp_Greater ||
                 sideEffectFuncOp == kIROp_Sub && compareOp == kIROp_Less)
@@ -535,7 +535,7 @@ namespace Slang
                 return;
             }
         }
-        else if (stepSize->value < 0)
+        else if (stepSize->getValue() < 0)
         {
             if (sideEffectFuncOp == kIROp_Add && compareOp == kIROp_Less ||
                 sideEffectFuncOp == kIROp_Sub && compareOp == kIROp_Greater)
@@ -553,25 +553,25 @@ namespace Slang
         if (!initialLitVal || !finalVal)
             return;
 
-        auto absStepSize = abs(stepSize->value);
+        auto absStepSize = abs(stepSize->getValue());
         int adjustment = 0;
         if (compareOp == kIROp_Geq || compareOp == kIROp_Leq)
             adjustment = 1;
 
-        auto iterations = (Math::Max(finalVal->value, initialLitVal->value) -
-            Math::Min(finalVal->value, initialLitVal->value) + absStepSize - 1 + adjustment) /
+        auto iterations = (Math::Max(finalVal->getValue(), initialLitVal->getValue()) -
+            Math::Min(finalVal->getValue(), initialLitVal->getValue()) + absStepSize - 1 + adjustment) /
             absStepSize;
         switch (compareOp)
         {
         case kIROp_Geq:
         case kIROp_Greater:
             // Expect final value to be less than initial value.
-            if (finalVal->value > initialLitVal->value)
+            if (finalVal->getValue() > initialLitVal->getValue())
                 iterations = 0;
             break;
         case kIROp_Leq:
         case kIROp_Less:
-            if (finalVal->value < initialLitVal->value)
+            if (finalVal->getValue() < initialLitVal->getValue())
                 iterations = 0;
             break;
         }
@@ -590,7 +590,7 @@ namespace Slang
         litExpr->type.type = m_astBuilder->getIntType();
         litExpr->token.setName(getNamePool()->getName(String(iterations)));
         maxItersAttr->args.add(litExpr);
-        maxItersAttr->intArgVals.add(0, m_astBuilder->getIntVal(m_astBuilder->getIntType(), iterations));
+        maxItersAttr->intArgVals.add(m_astBuilder->getIntVal(m_astBuilder->getIntType(), iterations));
         maxItersAttr->value = (int32_t)iterations;
         maxItersAttr->inductionVar = initialVar;
         addModifier(stmt, maxItersAttr);
diff --git a/source/slang/slang-check-type.cpp b/source/slang/slang-check-type.cpp
index cee54388f..d5d3e5a5d 100644
--- a/source/slang/slang-check-type.cpp
+++ b/source/slang/slang-check-type.cpp
@@ -17,6 +17,7 @@ namespace Slang
             sink);
         SemanticsVisitor visitor(&sharedSemanticsContext);
 
+        SLANG_AST_BUILDER_RAII(linkage->getASTBuilder());
 
         auto typeOut = visitor.CheckProperType(typeExp);
         return typeOut.type;
@@ -49,7 +50,7 @@ namespace Slang
         if (!typeRepr) return nullptr;
         if (auto typeType = as<TypeType>(typeRepr->type))
         {
-            return typeType->type;
+            return typeType->getType();
         }
         return m_astBuilder->getErrorType();
     }
@@ -86,11 +87,17 @@ namespace Slang
 
     Type* SemanticsVisitor::getRemovedModifierType(ModifiedType* modifiedType, ModifierVal* modifier)
     {
-        if (modifiedType->modifiers.getCount() == 1)
-            return modifiedType->base;
-        auto newModifiers = modifiedType->modifiers;
-        newModifiers.remove(modifier);
-        return m_astBuilder->getModifiedType(modifiedType->base, newModifiers);
+        if (modifiedType->getModifierCount() == 1)
+            return modifiedType->getBase();
+        List<Val*> newModifiers;
+        for (Index i = 0; i < modifiedType->getModifierCount(); i++)
+        {
+            auto m = modifiedType->getModifier(i);
+            if (m == modifier)
+                continue;
+            newModifiers.add(m);
+        }
+        return m_astBuilder->getModifiedType(modifiedType->getBase(), newModifiers);
     }
 
     Expr* SemanticsVisitor::ExpectATypeRepr(Expr* expr)
@@ -118,7 +125,7 @@ namespace Slang
         auto typeRepr = ExpectATypeRepr(expr);
         if (auto typeType = as<TypeType>(typeRepr->type))
         {
-            return typeType->type;
+            return typeType->getType();
         }
         return m_astBuilder->getErrorType();
     }
@@ -142,7 +149,7 @@ namespace Slang
         // constant expression in context, then we will instead construct
         // a dummy "error" value to represent the result.
         //
-        val = m_astBuilder->create<ErrorIntVal>();
+        val = m_astBuilder->getOrCreate<ErrorIntVal>(m_astBuilder->getIntType());
         return val;
     }
 
@@ -160,7 +167,7 @@ namespace Slang
         }
         if (auto typeType = as<TypeType>(exp->type))
         {
-            return typeType->type;
+            return typeType->getType();
         }
         else if (const auto errorType = as<ErrorType>(exp->type))
         {
@@ -187,10 +194,7 @@ namespace Slang
             evaledArgs.add(ExtractGenericArgVal(argExpr));
         }
 
-        GenericSubstitution* subst = m_astBuilder->getOrCreateGenericSubstitution(
-            genericDeclRef.getSubst(), genericDeclRef.getDecl(), evaledArgs);
-
-        DeclRef<Decl> innerDeclRef = m_astBuilder->getSpecializedDeclRef(getInner(genericDeclRef), subst);
+        DeclRef<Decl> innerDeclRef = m_astBuilder->getGenericAppDeclRef(genericDeclRef, evaledArgs.getArrayView());
         return DeclRefType::create(m_astBuilder, innerDeclRef);
     }
 
@@ -198,9 +202,9 @@ namespace Slang
     {
         if (auto declRefValueType = as<DeclRefType>(type))
         {
-            if (as<ClassDecl>(declRefValueType->declRef.getDecl()))
+            if (as<ClassDecl>(declRefValueType->getDeclRef().getDecl()))
                 return true;
-            if (as<InterfaceDecl>(declRefValueType->declRef.getDecl()))
+            if (as<InterfaceDecl>(declRefValueType->getDeclRef().getDecl()))
                 return true;
         }
         return false;
@@ -221,7 +225,7 @@ namespace Slang
 
             if(auto typeType = as<TypeType>(expr->type))
             {
-                type = typeType->type;
+                type = typeType->getType();
             }
         }
 
@@ -358,7 +362,7 @@ namespace Slang
         if (auto basicType = as<BasicExpressionType>(type))
         {
             // TODO: `void` shouldn't be a basic type, to make this easier to avoid
-            if (basicType->baseType == BaseType::Void)
+            if (basicType->getBaseType() == BaseType::Void)
             {
                 // TODO(tfoley): pick the right diagnostic message
                 getSink()->diagnose(result.exp, Diagnostics::invalidTypeVoid);
@@ -384,7 +388,7 @@ namespace Slang
         {
             if(auto rightConst = as<ConstantIntVal>(right))
             {
-                return leftConst->value == rightConst->value;
+                return leftConst->getValue() == rightConst->getValue();
             }
         }
 
@@ -392,16 +396,16 @@ namespace Slang
         {
             if(auto rightVar = as<GenericParamIntVal>(right))
             {
-                return leftVar->declRef.equals(rightVar->declRef);
+                return leftVar->getDeclRef().equals(rightVar->getDeclRef());
             }
             else if (const auto rightPoly = as<PolynomialIntVal>(right))
             {
-                return right->equalsVal(leftVar);
+                return right->equals(leftVar);
             }
         }
         if (auto leftVar = as<PolynomialIntVal>(left))
         {
-            return leftVar->equalsVal(right);
+            return leftVar->equals(right);
         }
         return false;
     }
@@ -423,22 +427,4 @@ namespace Slang
         return expr;
     }
 
-    Expr* SemanticsExprVisitor::visitTaggedUnionTypeExpr(TaggedUnionTypeExpr* expr)
-    {
-        // We have an expression of the form `__TaggedUnion(A, B, ...)`
-        // which will evaluate to a tagged-union type over `A`, `B`, etc.
-        //
-        TaggedUnionType* type = m_astBuilder->create<TaggedUnionType>();
-        expr->type = QualType(m_astBuilder->getTypeType(type));
-
-        for( auto& caseTypeExpr : expr->caseTypes )
-        {
-            caseTypeExpr = CheckProperType(caseTypeExpr);
-            type->caseTypes.add(caseTypeExpr.type);
-        }
-
-        return expr;
-    }
-
-
 }
diff --git a/source/slang/slang-check.cpp b/source/slang/slang-check.cpp
index 276e086df..780c109da 100644
--- a/source/slang/slang-check.cpp
+++ b/source/slang/slang-check.cpp
@@ -164,6 +164,8 @@ namespace Slang
         TranslationUnitRequest* translationUnit,
         LoadedModuleDictionary& loadedModules)
     {
+        SLANG_AST_BUILDER_RAII(translationUnit->compileRequest->getLinkage()->getASTBuilder());
+
         SharedSemanticsContext sharedSemanticsContext(
             translationUnit->compileRequest->getLinkage(),
             translationUnit->getModule(),
diff --git a/source/slang/slang-compiler.cpp b/source/slang/slang-compiler.cpp
index 224e30fa1..4e1ab8e98 100644
--- a/source/slang/slang-compiler.cpp
+++ b/source/slang/slang-compiler.cpp
@@ -265,7 +265,7 @@ namespace Slang
     {
         if (auto declaredWitness = as<DeclaredSubtypeWitness>(witness))
         {
-            auto declModule = getModule(declaredWitness->declRef.getDecl());
+            auto declModule = getModule(declaredWitness->getDeclRef().getDecl());
             m_moduleDependencyList.addDependency(declModule);
             m_fileDependencyList.addDependency(declModule);
             if (m_requirementSet.add(declModule))
@@ -276,8 +276,8 @@ namespace Slang
         }
         else if (auto transitiveWitness = as<TransitiveSubtypeWitness>(witness))
         {
-            addDepedencyFromWitness(transitiveWitness->midToSup);
-            addDepedencyFromWitness(transitiveWitness->subToMid);
+            addDepedencyFromWitness(transitiveWitness->getMidToSup());
+            addDepedencyFromWitness(transitiveWitness->getSubToMid());
         }
         else if (auto conjunctionWitness = as<ConjunctionSubtypeWitness>(witness))
         {
diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h
index 7d73599ba..79f6b6ed4 100755
--- a/source/slang/slang-compiler.h
+++ b/source/slang/slang-compiler.h
@@ -650,9 +650,6 @@ namespace Slang
         List<Module*> const& getModuleDependencies() SLANG_OVERRIDE { return m_moduleDependencies; }
         List<SourceFile*> const& getFileDependencies() SLANG_OVERRIDE { return m_fileDependencies; }
 
-                    /// Get a list of tagged-union types referenced by the specialization parameters.
-        List<TaggedUnionType*> const& getTaggedUnionTypes() { return m_taggedUnionTypes; }
-
         RefPtr<IRModule> getIRModule() { return m_irModule; }
 
         void acceptVisitor(ComponentTypeVisitor* visitor, SpecializationInfo* specializationInfo) SLANG_OVERRIDE;
@@ -679,9 +676,6 @@ namespace Slang
         List<String> m_entryPointMangledNames;
         List<String> m_entryPointNameOverrides;
 
-        // Any tagged union types that were referenced by the specialization arguments.
-        List<TaggedUnionType*> m_taggedUnionTypes;
-
         List<Module*> m_moduleDependencies;
         List<SourceFile*> m_fileDependencies;
         List<RefPtr<ComponentType>> m_requirements;
diff --git a/source/slang/slang-doc-markdown-writer.cpp b/source/slang/slang-doc-markdown-writer.cpp
index 9e9efeb64..c13dc9668 100644
--- a/source/slang/slang-doc-markdown-writer.cpp
+++ b/source/slang/slang-doc-markdown-writer.cpp
@@ -1119,7 +1119,7 @@ void DocMarkdownWriter::writeDescription(const ASTMarkup::Entry& entry)
 void DocMarkdownWriter::writeDecl(const ASTMarkup::Entry& entry, Decl* decl)
 {
     // Skip these they will be output as part of their respective 'containers'
-    if (as<ParamDecl>(decl) || as<EnumCaseDecl>(decl) || as<AssocTypeDecl>(decl) || as<InheritanceDecl>(decl))
+    if (as<ParamDecl>(decl) || as<EnumCaseDecl>(decl) || as<AssocTypeDecl>(decl) || as<InheritanceDecl>(decl) || as<ThisTypeDecl>(decl))
     {
         return; 
     }
diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp
index adfc98dfd..5bd57e81c 100644
--- a/source/slang/slang-emit-c-like.cpp
+++ b/source/slang/slang-emit-c-like.cpp
@@ -14,7 +14,6 @@
 #include "slang-ir-specialize.h"
 #include "slang-ir-specialize-resources.h"
 #include "slang-ir-ssa.h"
-#include "slang-ir-union.h"
 #include "slang-ir-util.h"
 #include "slang-ir-validate.h"
 #include "slang-legalize-types.h"
diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp
index 8f4d68a75..343c18916 100644
--- a/source/slang/slang-emit.cpp
+++ b/source/slang/slang-emit.cpp
@@ -54,7 +54,6 @@
 #include "slang-ir-strip-cached-dict.h"
 #include "slang-ir-strip-witness-tables.h"
 #include "slang-ir-synthesize-active-mask.h"
-#include "slang-ir-union.h"
 #include "slang-ir-validate.h"
 #include "slang-ir-wrap-structured-buffers.h"
 #include "slang-ir-liveness.h"
@@ -347,10 +346,6 @@ Result linkAndOptimizeIR(
     // Lower `Result<T,E>` types into ordinary struct types.
     lowerResultType(irModule, sink);
 
-    // Desguar any union types, since these will be illegal on
-    // various targets.
-    //
-    desugarUnionTypes(irModule);
 #if 0
     dumpIRIfEnabled(codeGenContext, irModule, "UNIONS DESUGARED");
 #endif
diff --git a/source/slang/slang-ir-inst-defs.h b/source/slang/slang-ir-inst-defs.h
index 4716ed427..69f3c4e0d 100644
--- a/source/slang/slang-ir-inst-defs.h
+++ b/source/slang/slang-ir-inst-defs.h
@@ -54,8 +54,6 @@ INST(Nop, nop, 0, 0)
     INST(VectorType, Vec, 2, HOISTABLE)
     INST(MatrixType, Mat, 3, HOISTABLE)
 
-    INST(TaggedUnionType, TaggedUnion, 0, HOISTABLE)
-
     INST(ConjunctionType, Conjunction, 0, HOISTABLE)
     INST(AttributedType, Attributed, 0, HOISTABLE)
     INST(ResultType, Result, 2, HOISTABLE)
@@ -985,7 +983,6 @@ INST(GetEquivalentStructuredBuffer,     getEquivalentStructuredBuffer, 1, 0)
         INST(ArrayTypeLayout, arrayTypeLayout, 1, HOISTABLE)
         INST(StreamOutputTypeLayout, streamOutputTypeLayout, 1, HOISTABLE)
         INST(MatrixTypeLayout, matrixTypeLayout, 1, HOISTABLE)
-        INST(TaggedUnionTypeLayout, taggedUnionTypeLayout, 0, HOISTABLE)
         INST(ExistentialTypeLayout, existentialTypeLayout, 0, HOISTABLE)
         INST(StructTypeLayout, structTypeLayout, 0, HOISTABLE)
         // TODO(JS): Ideally we'd have the layout to the pointed to value type (ie 1 instead of 0 here). But to avoid infinite recursion we don't.
diff --git a/source/slang/slang-ir-insts.h b/source/slang/slang-ir-insts.h
index 2312cc4f2..95f72b3cd 100644
--- a/source/slang/slang-ir-insts.h
+++ b/source/slang/slang-ir-insts.h
@@ -1717,59 +1717,6 @@ struct IRCaseTypeLayoutAttr : IRAttr
     }
 };
 
-    /// Specialized layout information for tagged union types
-struct IRTaggedUnionTypeLayout : IRTypeLayout
-{
-    typedef IRTypeLayout Super;
-
-    IR_LEAF_ISA(TaggedUnionTypeLayout)
-
-        /// Get the (byte) offset of the tagged union's tag (aka "discriminator") field
-    LayoutSize getTagOffset()
-    {
-        return LayoutSize::fromRaw(LayoutSize::RawValue(getIntVal(cast<IRIntLit>(getOperand(0)))));
-    }
-
-        /// Get all the attributes representing layouts for the difference cases
-    IROperandList<IRCaseTypeLayoutAttr> getCaseTypeLayoutAttrs()
-    {
-        return findAttrs<IRCaseTypeLayoutAttr>();
-    }
-
-        /// Get the number of cases for which layout information is stored
-    UInt getCaseCount()
-    {
-        return getCaseTypeLayoutAttrs().getCount();
-    }
-
-        /// Get the layout information for the case at the given `index`
-    IRTypeLayout* getCaseTypeLayout(UInt index)
-    {
-        return getCaseTypeLayoutAttrs()[index]->getTypeLayout();
-    }
-
-        /// Specialized builder for tagged union type layouts
-    struct Builder : Super::Builder
-    {
-        Builder(IRBuilder* irBuilder, LayoutSize tagOffset);
-
-        void addCaseTypeLayout(IRTypeLayout* typeLayout);
-
-        IRTaggedUnionTypeLayout* build()
-        {
-            return cast<IRTaggedUnionTypeLayout>(Super::Builder::build());
-        }
-
-    protected:
-        IROp getOp() SLANG_OVERRIDE { return kIROp_TaggedUnionTypeLayout; }
-        void addOperandsImpl(List<IRInst*>& ioOperands) SLANG_OVERRIDE;
-        void addAttrsImpl(List<IRInst*>& ioOperands) SLANG_OVERRIDE;
-
-        IRInst* m_tagOffset = nullptr;
-        List<IRAttr*> m_caseTypeLayoutAttrs;
-    };
-};
-
     /// Type layout for an existential/interface type.
 struct IRExistentialTypeLayout : IRTypeLayout
 {
@@ -3013,16 +2960,6 @@ public:
         IRRate* rate,
         IRType* dataType);
 
-    IRType* getTaggedUnionType(
-        UInt            caseCount,
-        IRType* const*  caseTypes);
-
-    IRType* getTaggedUnionType(
-        List<IRType*> const& caseTypes)
-    {
-        return getTaggedUnionType(caseTypes.getCount(), caseTypes.getBuffer());
-    }
-
     IRType* getBindExistentialsType(
         IRInst*         baseType,
         UInt            slotArgCount,
diff --git a/source/slang/slang-ir-link.cpp b/source/slang/slang-ir-link.cpp
index 081fd7486..364613074 100644
--- a/source/slang/slang-ir-link.cpp
+++ b/source/slang/slang-ir-link.cpp
@@ -240,7 +240,6 @@ IRInst* IRSpecContext::maybeCloneValue(IRInst* originalValue)
     case kIROp_GlobalGenericParam:
     case kIROp_WitnessTable:
     case kIROp_InterfaceType:
-    case kIROp_TaggedUnionType:
         return cloneGlobalValue(this, originalValue);
 
     case kIROp_BoolLit:
diff --git a/source/slang/slang-ir-union.cpp b/source/slang/slang-ir-union.cpp
deleted file mode 100644
index 1eb4955e7..000000000
--- a/source/slang/slang-ir-union.cpp
+++ /dev/null
@@ -1,773 +0,0 @@
-// slang-ir-union.cpp
-#include "slang-ir-union.h"
-
-#include "slang-ir.h"
-#include "slang-ir-insts.h"
-
-namespace Slang {
-
-// This file will implement a pass to replace any union types (currently
-// just tagged unions) with plain `struct` types that attempt to provide
-// equivalent semantics. This will necessarily be a bit fragile, and there
-// will be fundamental limits to what the translation can support without
-// improved features in the target shading languages/ILs.
-
-struct DesugarUnionTypesContext
-{
-    // We'll start with some basic state that we need to get the job done.
-    //
-    // This includes the IR module we are to process, as well as IR building
-    // state that we will initialize once and then use throughout the pass.
-    //
-    IRModule* module;
-    IRBuilder builderStorage;
-    IRBuilder* getBuilder() { return &builderStorage; }
-
-    // Because we will be replacing instructions that refer to unions with
-    // different logic, we'll want to remove the original instructions.
-    // However, we need to be careful about modifying the IR tree while also
-    // iterating it, and to keep things simple for ourselves we'll go ahead
-    // and build up a list of instruction to remove along the way, and then
-    // remove them all at the end.
-    //
-    List<IRInst*> instsToRemove;
-
-    // The overall flow of the pass is pretty simple, so we will walk through it now.
-    //
-    void processModule()
-    {
-        // We start by initializing our IR building state.
-        //
-        builderStorage = IRBuilder(module);
-
-        // Next, we will search for any instruction that create or use
-        // union types, and process them accordingingly (usually by
-        // constructing a new instruction to replace them).
-        //
-        processInstRec(module->getModuleInst());
-
-        // Along the way we will build up a list of the tagged union
-        // types that we encountered, but we will refrain from replacing
-        // them until we are done (so that we always know that the instructions
-        // we process above refer to the original type, and not its
-        // replacement.
-        //
-        for( auto info : taggedUnionInfos )
-        {
-            auto taggedUnionType = info->taggedUnionType;
-            auto replacementInst = info->replacementInst;
-
-            // TODO: We should consider transferring decorations from the source
-            // type to the destination, but doing so carelessly could create
-            // problems, since an IR struct type shouldn't have, e.g., a
-            // `TaggedUnionTypeLayout` attached to it.
-
-            taggedUnionType->replaceUsesWith(replacementInst);
-            taggedUnionType->removeAndDeallocate();
-        }
-
-        // As described previously, we build up the `instsToRemove` list as
-        // we iterate so that we can remove them all here and not risk
-        // modifying the IR tree while also walking it.
-        //
-        // TODO: This might be overkill and we could conceivably just be
-        // a bit careful in `processInstRec`.
-        //
-        for(auto inst : instsToRemove)
-        {
-            inst->removeAndDeallocate();
-        }
-    }
-
-    // In order to replace a (tagged) union type, we will need to know
-    // something about it, and we will use the `TaggedUnionInfo` type
-    // to collect all the relevant information.
-    //
-    struct TaggedUnionInfo : public RefObject
-    {
-        // We obviously need to know the tagged union itself, and
-        // we will also use this structure to track the instruction
-        // (an IR struct type) that will replace it.
-        //
-        IRTaggedUnionType*  taggedUnionType;
-        IRInst*             replacementInst;
-
-        // In order to compute a suitable layout for the replacement
-        // `struct` type we need to know how the tagged union itself
-        // would be laid out in memory, so we require that all tagged
-        // unions in the generated IR have an associated (target-specific)
-        // layout.
-        //
-        IRTaggedUnionTypeLayout* taggedUnionTypeLayout;
-
-        // The basic approach we will use 16-byte chunks (represented as an array
-        // of `uint4`s) to reprent the "bulk" of a type, and then use a single field
-        // that could be up to 12 bytes to represent the "rest" of the type.
-        //
-        // Note that there are deeply ingrained assumptions here that all types
-        // are at least four bytes in size (so that unions cannot easily
-        // accomodate `half` value), and that any types *larger* than four bytes
-        // will need to be loaded/stored via multiple 4-byte loads/stores.
-        //
-        // With the basic idea out of the way, we need an IR level field
-        // in our struct to hold the bulk data, which comprises a "key" for
-        // looking up the field, and the type of the field itself. We also
-        // keep track of how many bytes we put in our bulk storage.
-        //
-        // The bulk field might be:
-        //
-        // - null, if none of the case types was 16 bytes or more
-        // - a single `uint4` for between 16 and 31 (inclusive) bytes
-        // - an array of `uint4`s for 32 or more bytes
-        //
-        UInt64  bulkSize = 0;
-        IRInst* bulkFieldKey = nullptr;
-        IRType* bulkFieldType = nullptr;
-
-        // The same basic idea then applies to the rest of the data.
-        //
-        // The "rest" field will be either be absent (if the size of the
-        // type was evently divisible by 16), a scalar `uint`, or else
-        // a 2- or 3-component vector of `uint`.
-        //
-        UInt64  restSize = 0;
-        IRInst* restFieldKey = nullptr;
-        IRType* restFieldType = nullptr;
-
-        // Finally, since we are currently working with tagged unions,
-        // we need a field to hold the tag, which will always be allocated
-        // after the fields that hold the bulk/rest of the payload.
-        //
-        // This field is always a single `uint`.
-        //
-        // TODO: if/when we support untagged unions, they could be handled
-        // by having this field be null.
-        //
-        IRInst* tagFieldKey;
-    };
-
-    // We will build up a list of all the tagged union types we encounter,
-    // so that we can replace them with the synthesized types when we are done.
-    //
-    List<RefPtr<TaggedUnionInfo>> taggedUnionInfos;
-
-    // It is possible that we will see the same tagged union type referenced
-    // many times in the IR, but we only want to synthesize the information
-    // above (including the various IR structures) once, so we also maintain
-    // a map from the original IR type to the corresponding information.
-    //
-    Dictionary<IRInst*, TaggedUnionInfo*> mapIRTypeToTaggedUnionInfo;
-
-    // We will process all instructions in the module in a single recursive walk.
-    //
-    void processInstRec(IRInst* inst)
-    {
-        processInst(inst);
-
-        for( auto child : inst->getChildren() )
-        {
-            processInstRec(child);
-        }
-    }
-    //
-    // At each instruction, we will check if it is one of the union-related instructions
-    // we need to replace, and process it accordingly.
-    //
-    void processInst(IRInst* inst)
-    {
-        switch( inst->getOp() )
-        {
-        default:
-            // Any instruction not listed below either doesn't involve union types,
-            // or handles them in a hands-off fashion that we don't need to care about.
-            //
-            // E.g., a `load` of a union type from a constant buffer will turn into
-            // a load of the replacement `struct` type once we are done, and nothing
-            // needs to be done to the `load` instruction.
-            //
-            break;
-
-        case kIROp_TaggedUnionType:
-            {
-                // We clearly need to process the tagged union type itself, but the actual
-                // work is handled by other functions. All we need to do here is ensure
-                // that the information for this type gets generated, and then we can
-                // rely on the main `processModule` function to do the actual replacement later.
-                //
-                auto type = cast<IRTaggedUnionType>(inst);
-                getTaggedUnionInfo(type);
-            }
-            break;
-
-        case kIROp_ExtractTaggedUnionTag:
-            {
-                // The case of extracting the tag from a tagged union is relatively
-                // simple, because the replacement type will have a dedicated field or it.
-                //
-                // We start by finding the tagged union value the instruction is operating
-                // on, and then looking up the information for its type (which had
-                // better be a tagged union type).
-                //
-                auto taggedUnionVal = inst->getOperand(0);
-                auto taggedUnionInfo = getTaggedUnionInfo(taggedUnionVal->getDataType());
-
-                // Because the replacement type will have an explicit field for the tag,
-                // we can simply emit a single field-extract instruction to read its value
-                // out.
-                //
-                auto builder = getBuilder();
-                builder->setInsertBefore(inst);
-                auto replacement = builder->emitFieldExtract(
-                    inst->getFullType(),
-                    taggedUnionVal,
-                    taggedUnionInfo->tagFieldKey);
-
-                // Now we can replace anything that used the original instruction with
-                // the new field-extract operation, and add this instruction to the
-                // list for later removal.
-                //
-                inst->replaceUsesWith(replacement);
-                instsToRemove.add(inst);
-            }
-            break;
-
-        case kIROp_ExtractTaggedUnionPayload:
-            {
-                // The most interesting case is when we are trying to extract a particular
-                // payload (one of the case types) from a union. We may need to extract
-                // one or more fields from the data stored in the union's replacement
-                // type (the bulk/rest fields), and we may also have to convert them
-                // to the type expected via bit-casts.
-
-                // We can start things off easily enough by extracting the tagged union
-                // value being operated on, as well as the information for its type.
-                //
-                auto taggedUnionVal = inst->getOperand(0);
-                auto taggedUnionInfo = getTaggedUnionInfo(taggedUnionVal->getDataType());
-
-                // Next we need to figure out which case is being extracted from the union.
-                // The operand for the case tag should be a literal by construction.
-                //
-                auto caseTagVal = inst->getOperand(1);
-                auto caseTagConst = as<IRIntLit>(caseTagVal);
-                SLANG_ASSERT(caseTagConst);
-
-                // The case type we are extracting will be the result type of the instruciton.
-                //
-                auto caseType = inst->getDataType();
-                //
-                // The tag value itself will be the index of the case type in the union
-                // type (and its layout).
-                //
-                auto caseTagIndex = UInt(caseTagConst->getValue());
-
-                // We can use the case tag value to look up the layout for the particular
-                // case type we are extracting (this will allow us to resolve byte offsets
-                // for fields, etc.).
-                //
-                auto taggedUnionTypeLayout = taggedUnionInfo->taggedUnionTypeLayout;
-                SLANG_ASSERT(caseTagIndex < UInt(taggedUnionTypeLayout->getCaseCount()));
-                auto caseTypeLayout = taggedUnionTypeLayout->getCaseTypeLayout(caseTagIndex);
-
-                // At this point we know the type we are trying to extract, as well
-                // as its layout. We will defer the actual implementation of extraction
-                // to a (recursive) subroutine that can extract a (sub-)field from the
-                // union at a given byte offset. Since we are extracting a full case
-                // right now, the byte offset will be zero.
-                //
-                auto payloadVal = extractPayload(
-                    taggedUnionInfo,
-                    taggedUnionVal,
-                    caseType,
-                    caseTypeLayout,
-                    0);
-
-                // TODO: There is a significant flaw in the above approach when
-                // the case type might be (or contain) an array. If we have a setup
-                // like the following:
-                //
-                //      union SomeUnion { float someCase[100]; ... }
-                //      ...
-                //      float result = someUnion.someCase[someIndex];
-                //
-                // The current logic would desugar this into something like:
-                //
-                //      struct SomeUnion { uint4 bulk[100]; ... }
-                //      ...
-                //      float[] tmp = { asfloat(someUnion.bulk[0].x), asfloat(someUnion.bulk[1].x), ... }
-                //      float result = tmp[someIndex];
-                //
-                // The result is that we copy an entire 100-element array into local memory
-                // just to fetch a single element, when it would be much nicer to just do:
-                //
-                //      float result = asfloat(someUnion.bulk[someIndex].x);
-                //
-                // Achieving the latter code requires that rather than blindly translate
-                // the `extractTaggedUnionPayload` instruction into a semantically equiavlent
-                // value (which might lead to a big copy in the end), we should transitively
-                // chase down any "access chains" off of `inst` and see what leaf values are
-                // actually needed, and generated more tailored extraction logic for just
-                // the elements/fields that actually get referenced.
-                //
-                // The more refined approach can be built on top of many of the same primitives,
-                // so for now we will resign ourselves to the simpler but potentially less
-                // efficient approach.
-
-                // Now that we've extracted the value for the payload from the fields of
-                // the replacement struct, we can use that extracted value to replace
-                // this instruction, and schedule the original instruction for removal.
-                //
-                inst->replaceUsesWith(payloadVal);
-                instsToRemove.add(inst);
-            }
-            break;
-        }
-    }
-
-    // The `extractPayload` operation is the most important bit of translation we
-    // need to do to make unions work. We have as input the following:
-    //
-    IRInst* extractPayload(
-
-        // - Information about a tagged union type and its layout.
-        TaggedUnionInfo*    taggedUnionInfo,
-
-        // - A single value of that tagged unon type.
-        IRInst*             taggedUnionVal,
-
-        // - Type type of some "payload" field we want to extract from the union.
-        IRType*             payloadType,
-
-        // - The memory layout of that payload type.
-        IRTypeLayout*       payloadTypeLayout,
-
-        // - The byte offset at which we want to fetch the payload.
-        UInt64              payloadOffset)
-    {
-        // We are going to be building some IR code no matter what.
-        //
-        auto builder = getBuilder();
-
-        // The basic approach here will be to look at the type we
-        // are trying to extract from the union, and whenever possible
-        // recursively walk its structure so that we can express things
-        // in terms of extraction of smaller/simpler types.
-        //
-        if( auto irStructType = as<IRStructType>(payloadType) )
-        {
-            // A structure type is a nice recursive case: we simply
-            // want to extract each of its field recursively, and
-            // then construct a fresh value of the `struct` type.
-
-            // In all of the cases of this function we expect/require
-            // there to be complete type layout information for the
-            // types involved.
-            //
-            auto structTypeLayout = as<IRStructTypeLayout>(payloadTypeLayout);
-            SLANG_ASSERT(structTypeLayout);
-
-            // We are going to emit code to extract each of the fields
-            // and collect them to use as operands to a `makeStruct`.
-            //
-            List<IRInst*> fieldVals;
-
-            // We need to walk over the fields in the order the IR expects them
-            UInt fieldCounter = 0;
-            for( auto irField : irStructType->getFields() )
-            {
-                IRType* fieldType = irField->getFieldType();
-
-                // TODO: We need to confirm/enforce that the fields of the
-                // IR struct and the fields of the layout still align.
-                //
-                UInt fieldIndex = fieldCounter++;
-                auto fieldLayout = structTypeLayout->getFieldLayout(fieldIndex);
-                auto fieldTypeLayout = fieldLayout->getTypeLayout();
-
-                // The offset of the field can be computed from the base
-                // offset passed in, plus the reflection data for the field.
-                //
-                UInt64 fieldOffset = payloadOffset;
-                if(auto resInfo = fieldLayout->findOffsetAttr(LayoutResourceKind::Uniform))
-                    fieldOffset += resInfo->getOffset();
-
-                // We make a recursive call to extract each field, expecting
-                // that this will bottom out eventually.
-                //
-                IRInst* fieldVal = extractPayload(
-                    taggedUnionInfo,
-                    taggedUnionVal,
-                    fieldType,
-                    fieldTypeLayout,
-                    fieldOffset);
-                fieldVals.add(fieldVal);
-            }
-
-            // The final value is then just a new struct constructed from
-            // the extracted field values.
-            //
-            auto payloadVal = builder->emitMakeStruct(irStructType, fieldVals);
-            return payloadVal;
-        }
-        else if( auto vecType = as<IRVectorType>(payloadType) )
-        {
-            auto elementType = vecType->getElementType();
-
-            // We expect that by the time we are desugaring union types
-            // all vector types have literal constant values for their
-            // element count.
-            //
-            auto elementCountVal = vecType->getElementCount();
-            auto elementCountConst = as<IRIntLit>(elementCountVal);
-            SLANG_ASSERT(elementCountConst);
-            UInt elementCount = UInt(elementCountConst->getValue());
-
-            // HACK: There is currently no `VectorTypeLayout` and thus
-            // no way to query the layout of the elements of a vector
-            // type. Until that gets added we will kludge things here.
-            //
-            IRTypeLayout* elementTypeLayout = nullptr;
-            size_t elementSize = 0;
-            if(auto resInfo = payloadTypeLayout->findSizeAttr(LayoutResourceKind::Uniform))
-                elementSize = resInfo->getSize().getFiniteValue() / elementCount;
-
-            // Similar to the `struct` case above, we will extract a
-            // value for each element of the vector, and then use
-            // `makeVector` to construct the result value.
-            //
-            List<IRInst*> elementVals;
-            for(UInt ii = 0; ii < elementCount; ++ii)
-            {
-                auto elementVal = extractPayload(
-                    taggedUnionInfo,
-                    taggedUnionVal,
-                    elementType,
-                    elementTypeLayout,
-                    payloadOffset + ii*elementSize);
-                elementVals.add(elementVal);
-            }
-            return builder->emitMakeVector(vecType, elementVals);
-        }
-        else if( const auto matType = as<IRMatrixType>(payloadType) )
-        {
-            SLANG_UNIMPLEMENTED_X("matrix in union type");
-        }
-        else if( const auto arrayType = as<IRArrayType>(payloadType) )
-        {
-            SLANG_UNIMPLEMENTED_X("array in union type");
-        }
-        else
-        {
-            // If none of the above cases match, then we assume that
-            // we have an individual scalar field that we need to fetch.
-            //
-            UInt64 payloadSize = 0;
-            if( auto resInfo = payloadTypeLayout->findSizeAttr(LayoutResourceKind::Uniform) )
-            {
-                // TODO: somebody before this point should generate an error if
-                // we have a `union` type that contains a potentially unbounded
-                // amount of data.
-                //
-                payloadSize = resInfo->getSize().getFiniteValue();
-            }
-
-            if( payloadSize != 4 )
-            {
-                // TODO: We should handle the case of 64-bit fields by fetching
-                // two `uint` values to form a `uint2`, and then using an
-                // appropriate bit-cast to get from `uint2` to, e.g., `double`.
-                //
-                // The case of 16-bit and smaller fields is more troublesome, but
-                // in the worst case we can load a `uint` and then use bitwise
-                // ops to extract what we need before bitcasting.
-                //
-                // The right long-term solution is for downstream languages to have
-                // better support for raw memory addressing.
-
-                SLANG_UNIMPLEMENTED_X("leaf union field with size other than 4 bytes");
-            }
-
-            // We know that we want to fetch a value of size `payloadSize`, and
-            // we have a known base value and an initial offset into it.
-            //
-            IRInst* baseVal = taggedUnionVal;
-            UInt64 offset = payloadOffset;
-
-            // We are going to refine our `baseVal` and `offset` as we go, by
-            // trying to narrow down the data we will access in the `struct`
-            // type that will provide storage for the union.
-            //
-            // The first thing we want to check is if the value sits in the
-            // "bulk" part of the storage, or the "rest."
-            //
-            UInt64 bulkSize = taggedUnionInfo->bulkSize;
-            if( offset < bulkSize )
-            {
-                // If the value starts in the bulk area, then the whole
-                // thing had better fit in the bulk area. The 16-byte
-                // granularity rules for constant buffers should ensure
-                // this property for us on current targets.
-                //
-                SLANG_ASSERT(offset + payloadSize <= bulkSize);
-
-                // Since we know we'll be accessing the bulk storage,
-                // we will extract it here. The extracted field will
-                // be our new base value, but the `offset` doesn't need
-                // to be updated since the bulk field sits at offset 0.
-                //
-                baseVal = builder->emitFieldExtract(
-                    taggedUnionInfo->bulkFieldType,
-                    baseVal,
-                    taggedUnionInfo->bulkFieldKey);
-
-                // The bulk storage could be an array, if there are 32
-                // or more bytes of bulk storage.
-                //
-                if( auto baseArrayType = as<IRArrayType>(baseVal->getDataType()) )
-                {
-                    // If an array was allocated for bulk storage then
-                    // our leaf value resides entirely within a single
-                    // element (due to constant buffer layout rules),
-                    // and so we will fetch the appropriate element here.
-                    //
-                    // We will change our `baseVal` to the extracted element,
-                    // and then also adjust our `offset` to be relative
-                    // to that element.
-                    //
-                    size_t bulkElementSize = 16;
-                    auto index = offset / bulkElementSize;
-                    baseVal = builder->emitElementExtract(
-                        baseArrayType->getElementType(),
-                        baseVal,
-                        builder->getIntValue(builder->getIntType(), index));
-                    offset -= index*bulkElementSize;
-                }
-            }
-            else
-            {
-                // If the offset of the field we want is past the end of
-                // the bulk field then it must sit inside of the rest field,
-                // and we'll extract it here. This establishes a new
-                // base value, and we adjust the `offset` to be relative
-                // to the rest field (which starts at an offset equal to `bulkSize`).
-                //
-                baseVal = builder->emitFieldExtract(
-                    taggedUnionInfo->restFieldType,
-                    baseVal,
-                    taggedUnionInfo->restFieldKey);
-                offset -= bulkSize;
-            }
-
-            // We've now extracted a field that could be either a scalar or
-            // a vector, and we have an offset into it. In the case where
-            // the base value is a vector, we will extract out the appropriate
-            // element.
-            //
-            if( auto baseVecType = as<IRVectorType>(baseVal->getDataType()) )
-            {
-                size_t vecElementSize = 4;
-                auto index = offset / vecElementSize;
-                baseVal = builder->emitElementExtract(
-                    baseVecType->getElementType(),
-                    baseVal,
-                    builder->getIntValue(builder->getIntType(), index));
-                offset -= index*vecElementSize;
-            }
-
-            // At this point, our `baseVal` should be a single `uint`, and
-            // it should provide the storage for the exact thing we wanted
-            // to access (under the assumption that we always fetch 4 bytes
-            // on 4-byte alignment).
-            //
-            IRInst* payloadVal = baseVal;
-            SLANG_ASSERT(offset == 0);
-
-            // TODO: we could imagine adding logic here to handle types less
-            // than 4 bytes in size by shifting and masking the value we
-            // just loaded.
-
-            // The payload field we were trying to extract might have a type
-            // other than `uint`, and to handle that case we need to employ
-            // a bit-cast to get to the desired type.
-            //
-            if( payloadVal->getDataType() != payloadType )
-            {
-                payloadVal = builder->emitBitCast(
-                    payloadType,
-                    payloadVal);
-            }
-            return payloadVal;
-        }
-    }
-
-    // All of the logic so far as assumed we can just call `getTaggedUnionInfo`
-    // and have easy access to all the required information and the
-    // synthesized replacement type.
-    //
-    TaggedUnionInfo* getTaggedUnionInfo(IRType* type)
-    {
-        // The big picture is fairly simple: we will lazily build and
-        // memoize the information about tagged unions.
-        //
-        {
-            TaggedUnionInfo* info = nullptr;
-            if(mapIRTypeToTaggedUnionInfo.tryGetValue(type, info))
-                return info;
-        }
-
-        // When we don't find information in our memo-cache, we
-        // will construct it and add it to both the memo-cache
-        // *and* a global list of all tagged unions encountered,
-        // so that we can replacement them later.
-        //
-        auto info = createTaggedUnionInfo(type);
-        mapIRTypeToTaggedUnionInfo.add(type, info.Ptr());
-        taggedUnionInfos.add(info);
-
-        return info;
-    }
-
-    // The actual logic for creating a `TaggedUnionInfo` is relatively
-    // straightforward once we've decided what information we need.
-    //
-    RefPtr<TaggedUnionInfo> createTaggedUnionInfo(IRType* type)
-    {
-        // We expect that any type used as an operation to one of the
-        // `extractTaggedUnion*` operations must be an IR tagged union.
-        //
-        // Note: If/when we ever expose `union`s to user and allow
-        // then to create *generic* tagged union types it might appear
-        // that this needs to be changed to account for a `specialize`
-        // instruction in place of a concrete tagged union, but in
-        // practice this pass needs to be performed late enough that
-        // any such generic should be fully specialized.
-        //
-        auto taggedUnionType = as<IRTaggedUnionType>(type);
-        SLANG_ASSERT(taggedUnionType);
-
-        RefPtr<TaggedUnionInfo> info = new TaggedUnionInfo();
-        info->taggedUnionType = taggedUnionType;
-
-        // We are going to create an instruction to replace `type`,
-        // and thus will be placing it into the same parent.
-        //
-        auto builder = getBuilder();
-        builder->setInsertBefore(type);
-
-        // A tagged union type will be replaced with an ordinary
-        // `struct` type with fields to store all the relevant
-        // data from any of the cases, plus a tag field.
-        //
-        auto structType = builder->createStructType();
-        info->replacementInst = structType;
-
-        // We require/expect the earlier code generation steps to have
-        // associated a layout with every tagged union that appears in
-        // the code.
-        //
-        auto layoutDecoration = type->findDecoration<IRLayoutDecoration>();
-        SLANG_ASSERT(layoutDecoration);
-        auto layout = layoutDecoration->getLayout();
-        SLANG_ASSERT(layout);
-        auto taggedUnionTypeLayout = as<IRTaggedUnionTypeLayout>(layout);
-        SLANG_ASSERT(taggedUnionTypeLayout);
-
-        info->taggedUnionTypeLayout = taggedUnionTypeLayout;
-
-        // The size of the "payload" for the different cases (everything but
-        // the tag) is taken to be the offset of the tag itself.
-        //
-        // TODO: this might be inaccurate if the payload size isn't a multiple
-        // of the tag's alignment. We should deal with that when/if we support
-        // types smaller than 4 bytes in unions.
-        //
-        auto payloadSize = taggedUnionTypeLayout->getTagOffset().getFiniteValue();
-
-        // We are going to be construction IR code that makes use of the `int`
-        // and `uint` types in several cases, so we go ahead and get a pointer
-        // to those types here.
-        //
-        auto intType = getBuilder()->getIntType();
-        auto uintType = getBuilder()->getBasicType(BaseType::UInt);
-
-        // For now we will use a simple stragegy for how we encode a union,
-        // which depends only on the total number of bytes needed, and not
-        // on the makeup of the values being stored.
-        //
-        // We will start by allocating one or more `uint4` values (in an
-        // array for the "or more" case) to hold the bulk of any large
-        // payload value.
-        //
-        size_t bulkVectorSize = 16; // Note: assuming `sizeof(uint4) == 16` on all targets
-        auto bulkVectorCount = payloadSize / bulkVectorSize;
-        auto bulkFieldSize = bulkVectorCount * bulkVectorSize;
-        if( bulkVectorCount )
-        {
-            IRType* bulkFieldType = builder->getVectorType(
-                uintType,
-                builder->getIntValue(intType, 4));
-
-            if( bulkVectorCount > 1 )
-            {
-                bulkFieldType = builder->getArrayType(
-                    bulkFieldType,
-                    builder->getIntValue(intType, bulkVectorCount));
-            }
-
-            auto bulkFieldKey = builder->createStructKey();
-            builder->createStructField(structType, bulkFieldKey, bulkFieldType);
-
-            info->bulkFieldKey = bulkFieldKey;
-            info->bulkFieldType = bulkFieldType;
-        }
-        info->bulkSize = bulkFieldSize;
-
-        // The rest of the data (anything that doesn't fit in the bulk field),
-        // will get allocated into a single scalar or vector of `uint`.
-        //
-        auto restSize = payloadSize - bulkFieldSize;
-        if( restSize )
-        {
-            size_t restElementSize = 4; // assuming `sizeof(uint) == 4` on all targets
-            auto restElementCount = restSize / restElementSize;
-            auto restFieldSize = restElementSize * restElementCount;
-            SLANG_ASSERT(restFieldSize == restSize); // Note: all our current targets have minimum 4-byte storage granularity
-
-            IRType* restFieldType = uintType;
-            if( restElementCount > 1 )
-            {
-                restFieldType = builder->getVectorType(
-                    restFieldType,
-                    builder->getIntValue(intType, restElementCount));
-            }
-
-            auto restFieldKey = builder->createStructKey();
-            builder->createStructField(structType, restFieldKey, restFieldType);
-
-            info->restFieldKey = restFieldKey;
-            info->restFieldType = restFieldType;
-            info->restSize = restFieldSize;
-        }
-
-        // Finally, we add a field to represent the tag.
-        //
-        auto tagFieldType = uintType;
-        auto tagFieldKey = builder->createStructKey();
-        builder->createStructField(structType, tagFieldKey, tagFieldType);
-
-        info->tagFieldKey = tagFieldKey;
-
-        return info;
-    }
-};
-
-void desugarUnionTypes(
-    IRModule*       module)
-{
-    DesugarUnionTypesContext context;
-    context.module = module;
-
-    context.processModule();
-}
-
-} // namespace Slang
diff --git a/source/slang/slang-ir-union.h b/source/slang/slang-ir-union.h
deleted file mode 100644
index 81757dced..000000000
--- a/source/slang/slang-ir-union.h
+++ /dev/null
@@ -1,18 +0,0 @@
-// slang-ir-union.h
-#pragma once
-
-namespace Slang {
-
-struct IRModule;
-
-    /// Desugar any unions types, and code using them, in `module`
-    ///
-    /// Union types will be replaced with ordinary `struct` types that store
-    /// the data of the underlying type as a "bag of bits" and references
-    /// to cases of the union will be replaced with logic to extract the
-    /// relevant bits.
-    ///
-void desugarUnionTypes(
-    IRModule*       module);
-
-} // namespace Slang
diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp
index a27bf8658..38d1eb520 100644
--- a/source/slang/slang-ir.cpp
+++ b/source/slang/slang-ir.cpp
@@ -1004,32 +1004,6 @@ namespace Slang
     }
 
     //
-    // IRTaggedUnionTypeLayout
-    //
-
-    IRTaggedUnionTypeLayout::Builder::Builder(IRBuilder* irBuilder, LayoutSize tagOffset)
-        : Super::Builder(irBuilder)
-    {
-        m_tagOffset = irBuilder->getIntValue(irBuilder->getIntType(), tagOffset.raw);
-    }
-
-    void IRTaggedUnionTypeLayout::Builder::addCaseTypeLayout(IRTypeLayout* typeLayout)
-    {
-        m_caseTypeLayoutAttrs.add(getIRBuilder()->getCaseTypeLayoutAttr(typeLayout));
-    }
-
-    void IRTaggedUnionTypeLayout::Builder::addOperandsImpl(List<IRInst*>& ioOperands)
-    {
-        ioOperands.add(m_tagOffset);
-    }
-
-    void IRTaggedUnionTypeLayout::Builder::addAttrsImpl(List<IRInst*>& ioOperands)
-    {
-        for(auto attr : m_caseTypeLayoutAttrs)
-            ioOperands.add(attr);
-    }
-
-    //
     // IRVarLayout
     //
 
@@ -2981,17 +2955,6 @@ namespace Slang
             operands);
     }
 
-    IRType* IRBuilder::getTaggedUnionType(
-        UInt            caseCount,
-        IRType* const*  caseTypes)
-    {
-        return (IRType*)createIntrinsicInst(
-            getTypeKind(),
-            kIROp_TaggedUnionType,
-            caseCount,
-            (IRInst* const*) caseTypes);
-    }
-
     IRType* IRBuilder::getBindExistentialsType(
         IRInst*         baseType,
         UInt            slotArgCount,
@@ -3335,7 +3298,6 @@ namespace Slang
         IRInst* const*  args)
     {
         auto innerReturnVal = findInnerMostGenericReturnVal(as<IRGeneric>(genericVal));
-
         if (as<IRWitnessTable>(innerReturnVal))
         {
             return createIntrinsicInst(
@@ -3371,7 +3333,7 @@ namespace Slang
         // the emit logic, but this is a reasonably early place
         // to catch it.
         //
-        SLANG_ASSERT(witnessTableVal->getOp() != kIROp_StructKey);
+        SLANG_ASSERT(witnessTableVal && witnessTableVal->getOp() != kIROp_StructKey);
 
         IRInst* args[] = {witnessTableVal, interfaceMethodVal};
 
@@ -5536,6 +5498,8 @@ namespace Slang
             return emitIntrinsicInst(
                 getNativePtrType((IRType*)valueType->getOperand(0)), kIROp_GetNativePtr, 1, &value);
             break;
+        case kIROp_ExtractExistentialType:
+            return emitGetNativePtr(value->getOperand(0));
         default:
             SLANG_UNEXPECTED("invalid operand type for `getNativePtr`.");
             UNREACHABLE_RETURN(nullptr);
diff --git a/source/slang/slang-ir.h b/source/slang/slang-ir.h
index b0d9bb109..97f98fce2 100644
--- a/source/slang/slang-ir.h
+++ b/source/slang/slang-ir.h
@@ -1749,11 +1749,6 @@ struct IRInterfaceType : IRType
     IR_LEAF_ISA(InterfaceType)
 };
 
-struct IRTaggedUnionType : IRType
-{
-    IR_LEAF_ISA(TaggedUnionType)
-};
-
 struct IRConjunctionType : IRType
 {
     IR_LEAF_ISA(ConjunctionType)
diff --git a/source/slang/slang-language-server-ast-lookup.cpp b/source/slang/slang-language-server-ast-lookup.cpp
index e9c5f8fe5..d29cc4485 100644
--- a/source/slang/slang-language-server-ast-lookup.cpp
+++ b/source/slang/slang-language-server-ast-lookup.cpp
@@ -142,11 +142,6 @@ public:
 
     bool visitSharedTypeExpr(SharedTypeExpr* expr) { return dispatchIfNotNull(expr->base.exp); }
 
-    bool visitTaggedUnionTypeExpr(TaggedUnionTypeExpr*)
-    {
-        return false;
-    }
-
     bool visitInvokeExpr(InvokeExpr* expr)
     {
         PushNode pushNodeRAII(context, expr);
diff --git a/source/slang/slang-language-server-completion.cpp b/source/slang/slang-language-server-completion.cpp
index 6bccca8d3..4ec0ac64f 100644
--- a/source/slang/slang-language-server-completion.cpp
+++ b/source/slang/slang-language-server-completion.cpp
@@ -596,7 +596,7 @@ List<LanguageServerProtocol::CompletionItem> CompletionContext::createSwizzleCan
     {
         const char* memberNames[4] = {"x", "y", "z", "w"};
         Type* elementType = nullptr;
-        elementType = vectorType->elementType;
+        elementType = vectorType->getElementType();
         String typeStr;
         if (elementType)
             typeStr = elementType->toString();
diff --git a/source/slang/slang-language-server.cpp b/source/slang/slang-language-server.cpp
index e79716975..bc12ad34f 100644
--- a/source/slang/slang-language-server.cpp
+++ b/source/slang/slang-language-server.cpp
@@ -213,7 +213,7 @@ static bool isBoolType(Type* t)
     auto basicType = as<BasicExpressionType>(t);
     if (!basicType)
         return false;
-    return basicType->baseType == BaseType::Bool;
+    return basicType->getBaseType() == BaseType::Bool;
 }
 
 String getDeclKindString(DeclRef<Decl> declRef)
@@ -303,11 +303,11 @@ String getDeclSignatureString(DeclRef<Decl> declRef, WorkspaceVersion* version)
                         sb << " = ";
                         if (isBoolType(varDecl->getType()))
                         {
-                            sb << (constantInt->value ? "true" : "false");
+                            sb << (constantInt->getValue() ? "true" : "false");
                         }
                         else
                         {
-                            sb << constantInt->value;
+                            sb << constantInt->getValue();
                         }
                     }
                     else
@@ -492,6 +492,8 @@ SlangResult LanguageServer::hover(
     doc->zeroBasedUTF16LocToOneBasedUTF8Loc(args.position.line, args.position.character, line, col);
 
     auto version = m_workspace->getCurrentVersion();
+    SLANG_AST_BUILDER_RAII(version->linkage->getASTBuilder());
+
     Module* parsedModule = version->getOrLoadModule(canonicalPath);
     if (!parsedModule)
     {
@@ -741,6 +743,8 @@ SlangResult LanguageServer::gotoDefinition(
     doc->zeroBasedUTF16LocToOneBasedUTF8Loc(args.position.line, args.position.character, line, col);
 
     auto version = m_workspace->getCurrentVersion();
+    SLANG_AST_BUILDER_RAII(version->linkage->getASTBuilder());
+
     Module* parsedModule = version->getOrLoadModule(canonicalPath);
     if (!parsedModule)
     {
@@ -1029,6 +1033,8 @@ SlangResult LanguageServer::semanticTokens(
     }
 
     auto version = m_workspace->getCurrentVersion();
+    SLANG_AST_BUILDER_RAII(version->linkage->getASTBuilder());
+
     Module* parsedModule = version->getOrLoadModule(canonicalPath);
     if (!parsedModule)
     {
@@ -1073,6 +1079,7 @@ String LanguageServer::getExprDeclSignature(Expr* expr, String* outDocumentation
         return String();
 
     auto version = m_workspace->getCurrentVersion();
+    SLANG_AST_BUILDER_RAII(version->linkage->getASTBuilder());
 
     SignatureInformation sigInfo;
 
@@ -1096,7 +1103,7 @@ String LanguageServer::getExprDeclSignature(Expr* expr, String* outDocumentation
     bool isFirst = true;
     printer.getStringBuilder() << "(";
     int paramIndex = 0;
-    for (auto param : funcType->paramTypes)
+    for (auto param : funcType->getParamTypes())
     {
         if (!isFirst)
             printer.getStringBuilder() << ", ";
@@ -1134,6 +1141,8 @@ String LanguageServer::getExprDeclSignature(Expr* expr, String* outDocumentation
 String LanguageServer::getDeclRefSignature(DeclRef<Decl> declRef, String* outDocumentation, List<Slang::Range<Index>>* outParamRanges)
 {
     auto version = m_workspace->getCurrentVersion();
+    SLANG_AST_BUILDER_RAII(version->linkage->getASTBuilder());
+
     ASTPrinter printer(
         version->linkage->getASTBuilder(),
         ASTPrinter::OptionFlag::ParamNames | ASTPrinter::OptionFlag::NoInternalKeywords |
@@ -1169,6 +1178,8 @@ SlangResult LanguageServer::signatureHelp(
     doc->zeroBasedUTF16LocToOneBasedUTF8Loc(args.position.line, args.position.character, line, col);
 
     auto version = m_workspace->getCurrentVersion();
+    SLANG_AST_BUILDER_RAII(version->linkage->getASTBuilder());
+
     Module* parsedModule = version->getOrLoadModule(canonicalPath);
     if (!parsedModule)
     {
@@ -1289,7 +1300,7 @@ SlangResult LanguageServer::signatureHelp(
 
         printer.getStringBuilder() << "func (";
         bool isFirst = true;
-        for (auto param : funcType->paramTypes)
+        for (auto param : funcType->getParamTypes())
         {
             if (!isFirst)
                 printer.getStringBuilder() << ", ";
@@ -1315,12 +1326,12 @@ SlangResult LanguageServer::signatureHelp(
 
     if (auto declRefExpr = as<DeclRefExpr>(funcExpr))
     {
-        if (auto aggDecl = as<AggTypeDecl>(declRefExpr->declRef.getDecl()))
+        if (auto aggDeclRef = as<AggTypeDecl>(declRefExpr->declRef))
         {
             // Look for initializers
-            for (auto member : aggDecl->getMembersOfType<ConstructorDecl>())
+            for (auto member : getMembersOfType<ConstructorDecl>(version->linkage->getASTBuilder(), aggDeclRef))
             {
-                addDeclRef(version->linkage->getASTBuilder()->getSpecializedDeclRef<Decl>(member, declRefExpr->declRef.getSubst()));
+                addDeclRef(member);
             }
         }
         else
@@ -1379,6 +1390,8 @@ SlangResult LanguageServer::documentSymbol(
         return SLANG_OK;
     }
     auto version = m_workspace->getCurrentVersion();
+    SLANG_AST_BUILDER_RAII(version->linkage->getASTBuilder());
+
     Module* parsedModule = version->getOrLoadModule(canonicalPath);
     if (!parsedModule)
     {
@@ -1400,6 +1413,8 @@ SlangResult LanguageServer::inlayHint(const LanguageServerProtocol::InlayHintPar
         return SLANG_OK;
     }
     auto version = m_workspace->getCurrentVersion();
+    SLANG_AST_BUILDER_RAII(version->linkage->getASTBuilder());
+
     Module* parsedModule = version->getOrLoadModule(canonicalPath);
     if (!parsedModule)
     {
@@ -1518,6 +1533,8 @@ void LanguageServer::publishDiagnostics()
     m_lastDiagnosticUpdateTime = std::chrono::system_clock::now();
 
     auto version = m_workspace->getCurrentVersion();
+    SLANG_AST_BUILDER_RAII(version->linkage->getASTBuilder());
+
     // Send updates to clear diagnostics for files that no longer have any messages.
     List<String> filesToRemove;
     for (auto& file : m_lastPublishedDiagnostics)
diff --git a/source/slang/slang-lookup.cpp b/source/slang/slang-lookup.cpp
index 2eca91673..89d3380e4 100644
--- a/source/slang/slang-lookup.cpp
+++ b/source/slang/slang-lookup.cpp
@@ -16,7 +16,7 @@ void ensureDecl(SemanticsVisitor* visitor, Decl* decl, DeclCheckState state);
 
 //
 
-DeclRef<ExtensionDecl> ApplyExtensionToType(
+DeclRef<ExtensionDecl> applyExtensionToType(
     SemanticsVisitor*   semantics,
     ExtensionDecl*          extDecl,
     Type*  type);
@@ -161,14 +161,12 @@ static bool _isUncheckedLocalVar(const Decl* decl)
 static void _lookUpDirectAndTransparentMembers(
     ASTBuilder*             astBuilder,
     Name*                   name,
-    DeclRef<ContainerDecl>  containerDeclRef,
+    ContainerDecl*          containerDecl,       // The container decl to find member with `name`.
+    DeclRef<Decl>           parentDeclRef,       // The parent of the resulting declref.
     LookupRequest const&    request,
     LookupResult&           result,
     BreadcrumbInfo*         inBreadcrumbs)
 {
-    ContainerDecl* containerDecl = containerDeclRef.getDecl();
-
-
     if (request.isCompletionRequest())
     {
         // If we are looking up for completion suggestions,
@@ -182,7 +180,7 @@ static void _lookUpDirectAndTransparentMembers(
             AddToLookupResult(
                 result,
                 CreateLookupResultItem(
-                    astBuilder->getSpecializedDeclRef<Decl>(member, containerDeclRef.getSubst()), inBreadcrumbs));
+                    astBuilder->getMemberDeclRef<Decl>(parentDeclRef, member), inBreadcrumbs));
         }
     }
     else
@@ -207,7 +205,7 @@ static void _lookUpDirectAndTransparentMembers(
                 continue;
 
             // The declaration passed the test, so add it!
-            AddToLookupResult(result, CreateLookupResultItem(astBuilder->getSpecializedDeclRef<Decl>(m, containerDeclRef.getSubst()), inBreadcrumbs));
+            AddToLookupResult(result, CreateLookupResultItem(astBuilder->getMemberDeclRef<Decl>(parentDeclRef, m), inBreadcrumbs));
         }
     }
 
@@ -215,9 +213,9 @@ static void _lookUpDirectAndTransparentMembers(
     // if we already has a hit in the current container?
     for(auto transparentInfo : containerDecl->getTransparentMembers())
     {
-        // The reference to the transparent member should use whatever
-        // substitutions we used in referring to its outer container
-        DeclRef<Decl> transparentMemberDeclRef = astBuilder->getSpecializedDeclRef(transparentInfo.decl, containerDeclRef.getSubst());
+        // The reference to the transparent member should use the same
+        // path as we used in referring to its parent.
+        DeclRef<Decl> transparentMemberDeclRef = astBuilder->getMemberDeclRef(parentDeclRef, transparentInfo.decl);
 
         // We need to leave a breadcrumb so that we know that the result
         // of lookup involves a member lookup step here
@@ -262,7 +260,8 @@ LookupResult lookUpDirectAndTransparentMembers(
     ASTBuilder*             astBuilder,
     SemanticsVisitor*       semantics,
     Name*                   name,
-    DeclRef<ContainerDecl>  containerDeclRef,
+    ContainerDecl*          containerDecl,
+    DeclRef<Decl>           parentDeclRef,
     LookupMask              mask)
 {
     LookupRequest request = initLookupRequest(semantics, name, mask, LookupOptions::None, nullptr);
@@ -270,36 +269,14 @@ LookupResult lookUpDirectAndTransparentMembers(
     _lookUpDirectAndTransparentMembers(
         astBuilder,
         name,
-        containerDeclRef,
+        containerDecl,
+        parentDeclRef,
         request,
         result,
         nullptr);
     return result;
 }
 
-static SubtypeWitness* _makeSubtypeWitness(
-    ASTBuilder*                 astBuilder,
-    Type*                       subType,
-    SubtypeWitness*             subToMidWitness,
-    Type*                       superType,
-    SubtypeWitness*             midtoSuperWitness)
-{
-    SLANG_UNUSED(subType);
-    SLANG_UNUSED(superType);
-
-    if(subToMidWitness)
-    {
-        auto transitiveWitness = astBuilder->getTransitiveSubtypeWitness(
-            subToMidWitness,
-            midtoSuperWitness);
-        return transitiveWitness;
-    }
-    else
-    {
-        return midtoSuperWitness;
-    }
-}
-
 // Specialize `declRefToSpecialize` with ThisType info if `superType` is an interface type.
 DeclRef<Decl> _maybeSpecializeSuperTypeDeclRef(
     ASTBuilder* astBuilder,
@@ -309,14 +286,10 @@ DeclRef<Decl> _maybeSpecializeSuperTypeDeclRef(
 {
     if (auto superDeclRefType = as<DeclRefType>(superType))
     {
-        if (auto superInterfaceDeclRef = superDeclRefType->declRef.as<InterfaceDecl>())
+        if (auto superInterfaceDeclRef = superDeclRefType->getDeclRef().as<InterfaceDecl>())
         {
-            ThisTypeSubstitution* thisTypeSubst = astBuilder->getOrCreateThisTypeSubstitution(
-                superInterfaceDeclRef.getDecl(),
-                subIsSuperWitness,
-                declRefToSpecialize.getSubst());
-
-            auto specializedDeclRef = astBuilder->getSpecializedDeclRef<Decl>(declRefToSpecialize.getDecl(), thisTypeSubst);
+            ThisTypeDecl* thisTypeDecl = superInterfaceDeclRef.getDecl()->getThisTypeDecl();
+            auto specializedDeclRef = astBuilder->getLookupDeclRef(subIsSuperWitness, thisTypeDecl);
 
             return specializedDeclRef;
         }
@@ -332,7 +305,7 @@ static Type* _maybeSpecializeSuperType(
 {
     if (auto superDeclRefType = as<DeclRefType>(superType))
     {
-        auto specializedDeclRef = _maybeSpecializeSuperTypeDeclRef(astBuilder, superDeclRefType->declRef, superType, subIsSuperWitness);
+        auto specializedDeclRef = _maybeSpecializeSuperTypeDeclRef(astBuilder, superDeclRefType->getDeclRef(), superType, subIsSuperWitness);
         return DeclRefType::create(astBuilder, specializedDeclRef);
     }
 
@@ -391,14 +364,21 @@ static void _lookUpMembersInSuperType(
 }
 
 static void _lookUpMembersInSuperTypeDeclImpl(
-    ASTBuilder*             astBuilder,
-    Name*                   name,
+    ASTBuilder* astBuilder,
+    Name* name,
     DeclRef<Decl>           declRef,
-    LookupRequest const&    request,
-    LookupResult&           ioResult,
-    BreadcrumbInfo*         inBreadcrumbs)
+    LookupRequest const& request,
+    LookupResult& ioResult,
+    BreadcrumbInfo* inBreadcrumbs)
 {
     auto semantics = request.semantics;
+    if (!as<InterfaceDecl>(declRef.getDecl()) && name->text == "This")
+    {
+        // If we are looking for `This` in anything other than an InterfaceDecl,
+        // we just need to return the declRef itself.
+        AddToLookupResult(ioResult, CreateLookupResultItem(declRef, inBreadcrumbs));
+        return;
+    }
 
     // If the semantics context hasn't been established yet (e.g. when looking up during parsing),
     // we simply do a direct lookup without considering subtypes or extensions.
@@ -408,7 +388,7 @@ static void _lookUpMembersInSuperTypeDeclImpl(
         // In this case we can only lookup in an aggregate type.
         if (auto aggTypeDeclBaseRef = declRef.as<AggTypeDeclBase>())
         {
-            _lookUpDirectAndTransparentMembers(astBuilder, name, aggTypeDeclBaseRef, request, ioResult, inBreadcrumbs);
+            _lookUpDirectAndTransparentMembers(astBuilder, name, aggTypeDeclBaseRef.getDecl(), aggTypeDeclBaseRef, request, ioResult, inBreadcrumbs);
         }
         return;
     }
@@ -464,7 +444,7 @@ static void _lookUpMembersInSuperTypeDeclImpl(
         // relying on the modifier.
         if (auto declaredSubtypeWitness = as<DeclaredSubtypeWitness>(facet->subtypeWitness))
         {
-            auto inheritanceDeclRef = declaredSubtypeWitness->declRef;
+            auto inheritanceDeclRef = declaredSubtypeWitness->getDeclRef();
             if (inheritanceDeclRef.getDecl()->hasModifier<IgnoreForLookupModifier>())
                 continue;
         }
@@ -473,6 +453,7 @@ static void _lookUpMembersInSuperTypeDeclImpl(
 
         BreadcrumbInfo* newBreadcrumbs = inBreadcrumbs;
         BreadcrumbInfo subtypeInfo;
+        auto parentDeclRef = containerDeclRef;
         if (facet->directness != Facet::Directness::Self)
         {
             // Depending on the type of the facet, we may want to specialize the
@@ -487,9 +468,15 @@ static void _lookUpMembersInSuperTypeDeclImpl(
             // we should also specialize the interface declRef with the concrete
             // type info.
             //
-            containerDeclRef = _maybeSpecializeSuperTypeDeclRef(
+            parentDeclRef = _maybeSpecializeSuperTypeDeclRef(
                 astBuilder, containerDeclRef, facet->getType(), facet->subtypeWitness)
                 .as<ContainerDecl>();
+            if (as<ThisTypeDecl>(parentDeclRef.getDecl()) && name->text == "This")
+            {
+                // If we are going looking for `This` in a `ThisType`, we just need to return the declRef itself.
+                AddToLookupResult(ioResult, CreateLookupResultItem(parentDeclRef, inBreadcrumbs));
+                continue;
+            }
 
             // If we are looking up in a base type, we also need to make sure
             // to create a breadcrumb to track the sub to super indirection.
@@ -502,7 +489,7 @@ static void _lookUpMembersInSuperTypeDeclImpl(
                 newBreadcrumbs = &subtypeInfo;
             }
         }
-        _lookUpDirectAndTransparentMembers(astBuilder, name, containerDeclRef, request, ioResult, newBreadcrumbs);
+        _lookUpDirectAndTransparentMembers(astBuilder, name, containerDeclRef.getDecl(), parentDeclRef, request, ioResult, newBreadcrumbs);
     }
 }
 
@@ -540,7 +527,7 @@ static void _lookUpMembersInSuperTypeImpl(
 
     if(auto declRefType = as<DeclRefType>(superType))
     {
-        auto declRef = declRefType->declRef;
+        auto declRef = declRefType->getDeclRef();
 
         _lookUpMembersInSuperTypeDeclImpl(astBuilder, name, declRef, request, ioResult, inBreadcrumbs);
     }
@@ -551,36 +538,16 @@ static void _lookUpMembersInSuperTypeImpl(
         // lookup will have a comparable substitution applied (allowing things like associated
         // types, etc. used in the signature of a method to resolve correctly).
         //
-        auto interfaceDeclRef = extractExistentialType->getSpecializedInterfaceDeclRef();
-        _lookUpMembersInSuperTypeDeclImpl(astBuilder, name, interfaceDeclRef, request, ioResult, inBreadcrumbs);
-    }
-    else if( auto thisType = as<ThisType>(superType) )
-    {
-        // We need to create a witness that represents the next link in the
-        // chain. The `leafIsSuperWitness` represents the knowledge that `leafType : superType`
-        // (and we know that `superType == thisType`,  but we now need to extend that
-        // with the knowledge that `thisType : thisType->interfaceTypeDeclRef`.
-        //
-        auto interfaceType = DeclRefType::create(astBuilder, thisType->interfaceDeclRef);
-
-        auto superIsInterfaceWitness = astBuilder->getThisTypeSubtypeWitness(superType, interfaceType);
-
-        auto leafIsInterfaceWitness = _makeSubtypeWitness(
-            astBuilder,
-            leafType,
-            leafIsSuperWitness,
-            interfaceType,
-            superIsInterfaceWitness);
-
-        _lookUpMembersInSuperType(astBuilder, name, leafType, interfaceType, leafIsInterfaceWitness, request, ioResult, inBreadcrumbs);
+        auto thisTypeDeclRef = extractExistentialType->getThisTypeDeclRef();
+        _lookUpMembersInSuperTypeDeclImpl(astBuilder, name, thisTypeDeclRef, request, ioResult, inBreadcrumbs);
     }
     else if( auto andType = as<AndType>(superType) )
     {
         // We have a type of the form `leftType & rightType` and we need to perform
         // lookup in both `leftType` and `rightType`.
         //
-        auto leftType = andType->left;
-        auto rightType = andType->right;
+        auto leftType = andType->getLeft();
+        auto rightType = andType->getRight();
 
         // Operationally, we are in a situation where we have a witness
         // that the `leafType` we are doing lookup on is an subtype
@@ -731,7 +698,7 @@ static void _lookUpInScopes(
             // just a decl.
             //
             DeclRef<ContainerDecl> containerDeclRef =
-                astBuilder->getSpecializedDeclRef<Decl>(containerDecl, createDefaultSubstitutions(astBuilder, request.semantics, containerDecl)).as<ContainerDecl>();
+                createDefaultSubstitutionsIfNeeded(astBuilder, request.semantics, makeDeclRef(containerDecl)).as<ContainerDecl>();
 
             // If the container we are looking into represents a type
             // or an `extension` of a type, then we need to treat
@@ -755,7 +722,7 @@ static void _lookUpInScopes(
                 breadcrumb.thisParameterMode = thisParameterMode;
                 breadcrumb.declRef = aggTypeDeclBaseRef;
                 breadcrumb.prev = nullptr;
-
+                BreadcrumbInfo* breadcrumbPtr = &breadcrumb;
                 Type* type = nullptr;
                 if (auto extDeclRef = aggTypeDeclBaseRef.as<ExtensionDecl>())
                 {
@@ -773,10 +740,25 @@ static void _lookUpInScopes(
                 else
                 {
                     assert(aggTypeDeclBaseRef.as<AggTypeDecl>());
-                    type = DeclRefType::create(astBuilder, aggTypeDeclBaseRef);
+                    if (auto interfaceBase = as<InterfaceDecl>(aggTypeDeclBaseRef.getDecl()))
+                    {
+                        // When looking up inside an interface type, we are actually looking up through ThisType.
+                        if (name != interfaceBase->getThisTypeDecl()->getName())
+                        {
+                            type = DeclRefType::create(astBuilder, astBuilder->getMemberDeclRef(aggTypeDeclBaseRef, interfaceBase->getThisTypeDecl()));
+                            // Don't need any breadcrumb for looking up through ThisType, since we have already
+                            // created the base type reference in the new `type`'s declref.
+                            breadcrumbPtr = nullptr;
+                        }
+                    }
+                    
+                    if (!type)
+                    {
+                        type = DeclRefType::create(astBuilder, aggTypeDeclBaseRef);
+                    }
                 }
 
-                _lookUpMembersInType(astBuilder, name, type, request, result, &breadcrumb);
+                _lookUpMembersInType(astBuilder, name, type, request, result, breadcrumbPtr);
             }
             else
             {
@@ -784,7 +766,7 @@ static void _lookUpInScopes(
                 // type or `extension` declaration, so we can look up members
                 // in that scope much more simply.
                 //
-                _lookUpDirectAndTransparentMembers(astBuilder, name, containerDeclRef, request, result, nullptr);
+                _lookUpDirectAndTransparentMembers(astBuilder, name, containerDeclRef.getDecl(), containerDeclRef, request, result, nullptr);
             }
 
             // Before we proceed up to the next outer scope to perform lookup
diff --git a/source/slang/slang-lookup.h b/source/slang/slang-lookup.h
index 69374c024..8af760f70 100644
--- a/source/slang/slang-lookup.h
+++ b/source/slang/slang-lookup.h
@@ -35,7 +35,8 @@ LookupResult lookUpDirectAndTransparentMembers(
     ASTBuilder*             astBuilder,
     SemanticsVisitor*       semantics,
     Name*                   name,
-    DeclRef<ContainerDecl>  containerDeclRef,
+    ContainerDecl*          containerDecl,
+    DeclRef<Decl>           parentDeclRef,       // The parent of the resulting declref.
     LookupMask              mask = LookupMask::Default);
 
 // TODO: this belongs somewhere else
diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp
index 0773226d1..e0e97d6e7 100644
--- a/source/slang/slang-lower-to-ir.cpp
+++ b/source/slang/slang-lower-to-ir.cpp
@@ -804,7 +804,7 @@ LoweredValInfo emitCallToDeclRef(
 
     if( auto ctorDeclRef = funcDeclRef.as<ConstructorDecl>() )
     {
-        if(!ctorDeclRef.getDecl()->body && isFromStdLib(ctorDeclRef.getDecl()) && !as<InterfaceDecl>(ctorDeclRef.getParent(context->astBuilder).getDecl()))
+        if(!ctorDeclRef.getDecl()->body && isFromStdLib(ctorDeclRef.getDecl()) && !as<InterfaceDecl>(ctorDeclRef.getParent().getDecl()))
         {
             SLANG_UNREACHABLE("stdlib error: __init() has no definition.");
         }
@@ -1399,7 +1399,7 @@ void getGenericTypeConformances(IRGenContext* context, ShortList<IRType*>& supTy
         {
             if (auto declRefType = as<DeclRefType>(typeConstraint->sub.type))
             {
-                if (declRefType->declRef.getDecl() == genericParamDecl)
+                if (declRefType->getDeclRef().getDecl() == genericParamDecl)
                 {
                     supTypes.add(lowerType(context, typeConstraint->getSup().type));
                 }
@@ -1408,6 +1408,36 @@ void getGenericTypeConformances(IRGenContext* context, ShortList<IRType*>& supTy
     }
 }
 
+
+// Check if declRef represents a witness that `ISomeInterface.This : ISomeInterface`.
+static bool _isThisTypeSubtypeWitness(DeclRefBase* declRef)
+{
+    auto lookupDeclRef = as<LookupDeclRef>(declRef);
+    if (!lookupDeclRef)
+        return false;
+    if (!as<ThisType>(lookupDeclRef->getLookupSource()))
+        return false;
+    auto declaredWitness = as<DeclaredSubtypeWitness>(lookupDeclRef->getWitness());
+    if (!declaredWitness)
+        return false;
+    if (!as<ThisTypeConstraintDecl>(declaredWitness->getDeclRef()))
+        return false;
+    return true;
+}
+
+// Returns whether `declRef` represents a trivial lookup of an interface requirement
+// through `ThisTypeDecl` made from within the same interface Decl.
+static bool _isTrivialLookupFromInterfaceThis(IRGenContext* context, DeclRefBase* declRef)
+{
+    if (!_isThisTypeSubtypeWitness(declRef))
+        return false;
+    // This is a lookup from an interface's This type.
+    // If the lookup is made from an interface type itself rather than an extension of it,
+    // then it is a trivial lookup and we should lower it as a struct key.
+    return context->thisTypeWitness == nullptr;
+}
+
+
 //
 
 struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, LoweredValInfo>
@@ -1424,24 +1454,24 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     LoweredValInfo visitGenericParamIntVal(GenericParamIntVal* val)
     {
-        return emitDeclRef(context, val->declRef,
-            lowerType(context, getType(context->astBuilder, val->declRef)));
+        return emitDeclRef(context, val->getDeclRef(),
+            lowerType(context, getType(context->astBuilder, val->getDeclRef())));
     }
 
     LoweredValInfo visitFuncCallIntVal(FuncCallIntVal* val)
     {
         TryClauseEnvironment tryEnv;
         List<IRInst*> args;
-        for (auto arg : val->args)
+        for (auto arg : val->getArgs())
         {
             auto loweredArg = lowerVal(context, arg);
             args.add(loweredArg.val);
         }
-        auto funcType = lowerType(context, val->funcType);
+        auto funcType = lowerType(context, val->getFuncType());
         return emitCallToDeclRef(
             context,
             as<IRFuncType>(funcType)->getResultType(),
-            val->funcDeclRef,
+            val->getFuncDeclRef(),
             funcType,
             args,
             tryEnv);
@@ -1449,17 +1479,17 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     LoweredValInfo visitTypeCastIntVal(TypeCastIntVal* val)
     {
-        auto baseVal = lowerVal(context, val->base);
+        auto baseVal = lowerVal(context, val->getBase());
         SLANG_ASSERT(baseVal.flavor == LoweredValInfo::Flavor::Simple);
-        auto type = lowerType(context, val->type);
+        auto type = lowerType(context, val->getType());
         return LoweredValInfo::simple(getBuilder()->emitCast(type, baseVal.val));
     }
 
     LoweredValInfo visitWitnessLookupIntVal(WitnessLookupIntVal* val)
     {
-        auto witnessVal = lowerVal(context, val->witness);
-        auto key = getInterfaceRequirementKey(context, val->key);
-        auto type = lowerType(context, val->type);
+        auto witnessVal = lowerVal(context, val->getWitness());
+        auto key = getInterfaceRequirementKey(context, val->getKey());
+        auto type = lowerType(context, val->getType());
         return LoweredValInfo::simple(getBuilder()->emitLookupInterfaceMethodInst(
             type, witnessVal.val, key));
     }
@@ -1467,16 +1497,16 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
     LoweredValInfo visitPolynomialIntVal(PolynomialIntVal* val)
     {
         auto irBuilder = getBuilder();
-        auto type = lowerType(context, val->type);
-        auto constTerm = irBuilder->getIntValue(type, val->constantTerm);
+        auto type = lowerType(context, val->getType());
+        auto constTerm = irBuilder->getIntValue(type, val->getConstantTerm());
         auto resultVal = constTerm;
-        for (auto term : val->terms)
+        for (auto term : val->getTerms())
         {
-            auto termVal = irBuilder->getIntValue(type, term->constFactor);
-            for (auto factor : term->paramFactors)
+            auto termVal = irBuilder->getIntValue(type, term->getConstFactor());
+            for (auto factor : term->getParamFactors())
             {
-                auto factorVal = lowerVal(context, factor->param).val;
-                for (IntegerLiteralValue i = 0; i < factor->power; i++)
+                auto factorVal = lowerVal(context, factor->getParam()).val;
+                for (IntegerLiteralValue i = 0; i < factor->getPower(); i++)
                 {
                     termVal = irBuilder->emitMul(factorVal->getDataType(), termVal, factorVal);
                 }
@@ -1488,9 +1518,12 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     LoweredValInfo visitDeclaredSubtypeWitness(DeclaredSubtypeWitness* val)
     {
-        return emitDeclRef(context, val->declRef,
+        if (as<ThisTypeConstraintDecl>(val->getDeclRef()))
+            return LoweredValInfo::simple(context->thisTypeWitness);
+
+        return emitDeclRef(context, val->getDeclRef(),
             context->irBuilder->getWitnessTableType(
-                lowerType(context, val->sup)));
+                lowerType(context, val->getSup())));
     }
 
     LoweredValInfo visitTransitiveSubtypeWitness(
@@ -1498,7 +1531,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
     {
         // The base (subToMid) will turn into a value with
         // witness-table type.
-        IRInst* baseWitnessTable = lowerSimpleVal(context, val->subToMid);
+        IRInst* baseWitnessTable = lowerSimpleVal(context, val->getSubToMid());
         IRInst* midToSup = nullptr;
 
         // The next step should map to an interface requirement
@@ -1530,17 +1563,17 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
             return LoweredValInfo::simple(midToSup);
         }
 
-        if (auto declaredMidToSup = as<DeclaredSubtypeWitness>(val->midToSup))
+        if (auto declaredMidToSup = as<DeclaredSubtypeWitness>(val->getMidToSup()))
         {
-            midToSup = getInterfaceRequirementKey(context, declaredMidToSup->declRef.getDecl());
+            midToSup = getInterfaceRequirementKey(context, declaredMidToSup->getDeclRef().getDecl());
         }
         else
         {
-            midToSup = lowerSimpleVal(context, val->midToSup);
+            midToSup = lowerSimpleVal(context, val->getMidToSup());
         }
 
         return LoweredValInfo::simple(getBuilder()->emitLookupInterfaceMethodInst(
-            getBuilder()->getWitnessTableType(lowerType(context, val->sup)),
+            getBuilder()->getWitnessTableType(lowerType(context, val->getSup())),
             baseWitnessTable,
             midToSup));
     }
@@ -1550,7 +1583,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
         // TODO: properly fill in type info here.
         // We should consider fold all cases of witness table entries to `Val`, and make the `DeclRef` case a `DeclRefVal`.
         // So that we can hold the type in `DeclRefVal`.
-        auto funcVal = emitDeclRef(context, val->func, context->irBuilder->getTypeKind());
+        auto funcVal = emitDeclRef(context, val->getFunc(), context->irBuilder->getTypeKind());
         SLANG_RELEASE_ASSERT(funcVal.flavor == LoweredValInfo::Flavor::Simple);
 
         auto diff = getBuilder()->emitForwardDifferentiateInst(getBuilder()->getTypeKind(), funcVal.val);
@@ -1559,7 +1592,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     LoweredValInfo visitBackwardDifferentiateVal(BackwardDifferentiateVal* val)
     {
-        auto funcVal = emitDeclRef(context, val->func, context->irBuilder->getTypeKind());
+        auto funcVal = emitDeclRef(context, val->getFunc(), context->irBuilder->getTypeKind());
         SLANG_RELEASE_ASSERT(funcVal.flavor == LoweredValInfo::Flavor::Simple);
 
         auto diff = getBuilder()->emitBackwardDifferentiateInst(getBuilder()->getTypeKind(), funcVal.val);
@@ -1568,7 +1601,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     LoweredValInfo visitBackwardDifferentiatePropagateVal(BackwardDifferentiatePropagateVal* val)
     {
-        auto funcVal = emitDeclRef(context, val->func, context->irBuilder->getTypeKind());
+        auto funcVal = emitDeclRef(context, val->getFunc(), context->irBuilder->getTypeKind());
         SLANG_RELEASE_ASSERT(funcVal.flavor == LoweredValInfo::Flavor::Simple);
 
         auto diff = getBuilder()->emitBackwardDifferentiatePropagateInst(getBuilder()->getTypeKind(), funcVal.val);
@@ -1577,7 +1610,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     LoweredValInfo visitBackwardDifferentiatePrimalVal(BackwardDifferentiatePrimalVal* val)
     {
-        auto funcVal = emitDeclRef(context, val->func, context->irBuilder->getTypeKind());
+        auto funcVal = emitDeclRef(context, val->getFunc(), context->irBuilder->getTypeKind());
         SLANG_RELEASE_ASSERT(funcVal.flavor == LoweredValInfo::Flavor::Simple);
 
         auto diff = getBuilder()->emitBackwardDifferentiatePrimalInst(getBuilder()->getTypeKind(), funcVal.val);
@@ -1586,280 +1619,18 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     LoweredValInfo visitBackwardDifferentiateIntermediateTypeVal(BackwardDifferentiateIntermediateTypeVal* val)
     {
-        auto funcVal = emitDeclRef(context, val->func, context->irBuilder->getTypeKind());
+        auto funcVal = emitDeclRef(context, val->getFunc(), context->irBuilder->getTypeKind());
         SLANG_RELEASE_ASSERT(funcVal.flavor == LoweredValInfo::Flavor::Simple);
 
         auto diff = getBuilder()->getBackwardDiffIntermediateContextType(funcVal.val);
         return LoweredValInfo::simple(diff);
     }
 
-    LoweredValInfo visitTaggedUnionSubtypeWitness(
-        TaggedUnionSubtypeWitness* val)
-    {
-        // The sub-type in this case is a tagged union `A | B | ...`,
-        // and the witness holds an array of witnesses showing that each
-        // "case" (`A`, `B`, etc.) is a subtype of the super-type.
-
-        // We will start by getting the IR-level representation of the
-        // sub type (the tagged union type).
-        //
-        auto irTaggedUnionType = lowerType(context, val->sub);
-
-        // We can turn each of those per-case witnesses into a witness
-        // table value:
-        //
-        auto caseCount = val->caseWitnesses.getCount();
-        List<IRInst*> caseWitnessTables;
-        for( auto caseWitness : val->caseWitnesses )
-        {
-            auto caseWitnessTable = lowerSimpleVal(context, caseWitness);
-            caseWitnessTables.add(caseWitnessTable);
-        }
-
-        // Now we need to synthesize a witness table for the tagged union
-        // value, showing how it can implement all of the requirements
-        // of the super type by delegating to the appropriate implementation
-        // on a per-case basis.
-        //
-        // We will assume here that the super-type is an interface, and it
-        // will be left to the front-end to ensure this property.
-        //
-        auto supDeclRefType = as<DeclRefType>(val->sup);
-        if(!supDeclRefType)
-        {
-            SLANG_UNEXPECTED("super-type not a decl-ref type when generating tagged union witness table");
-            UNREACHABLE_RETURN(LoweredValInfo());
-        }
-        auto supInterfaceDeclRef = supDeclRefType->declRef.as<InterfaceDecl>();
-        if( !supInterfaceDeclRef )
-        {
-            SLANG_UNEXPECTED("super-type not an interface type when generating tagged union witness table");
-            UNREACHABLE_RETURN(LoweredValInfo());
-        }
-
-        auto subType = lowerType(context, val->sub);
-        auto irWitnessTableBaseType = lowerType(context, supDeclRefType);
-        auto irWitnessTable = getBuilder()->createWitnessTable(irWitnessTableBaseType, subType);
-
-        // Now we will iterate over the requirements (members) of the
-        // interface and try to synthesize an appropriate value for each.
-        //
-        for( auto reqDeclRef : getMembers(context->astBuilder, supInterfaceDeclRef) )
-        {
-            // TODO: if there are any members we shouldn't process as a requirement,
-            // then we should detect and skip them here.
-            //
-
-            // Every interface requirement will have a unique key that is used
-            // when looking up the requirement in a concrete witness table.
-            //
-            auto irReqKey = getInterfaceRequirementKey(context, reqDeclRef.getDecl());
-
-            if (!irReqKey)
-                continue;
-
-            // We expect that each of the witness tables in `caseWitnessTables`
-            // will have an entry to match these keys. However, we may not
-            // have a concrete `IRWitnessTable` for each of the case types, either
-            // because they are a specialization of a generic (so that the witness
-            // table reference is a `specialize` instruction at this point), or
-            // they are a type external to this module (so that we have a declaration
-            // rather than a definition of the witness table).
-
-            // Our task is to create an IR value that can satisfy the interface
-            // requirement for the tagged union type, by appropriately delegating
-            // to the implementations of the same requirement in the case types.
-            //
-            IRInst* irSatisfyingVal = nullptr;
-
-
-
-            if(auto callableDeclRef = reqDeclRef.as<CallableDecl>())
-            {
-                // We have something callable, so we need to synthesize
-                // a function to satisfy it.
-                //
-                auto irFunc = getBuilder()->createFunc();
-                irSatisfyingVal = irFunc;
-
-                IRBuilder subBuilderStorage = *getBuilder();
-                auto subBuilder = &subBuilderStorage;
-                subBuilder->setInsertInto(irFunc);
-
-                // We will start by setting up the function parameters,
-                // which live in the entry block of the IR function.
-                //
-                auto entryBlock = subBuilder->emitBlock();
-                subBuilder->setInsertInto(entryBlock);
-
-                // Create a `this` parameter of the tagged-union type.
-                //
-                // TODO: need to handle the `[mutating]` case here...
-                //
-                auto irThisType = irTaggedUnionType;
-                auto irThisParam = subBuilder->emitParam(irThisType);
-
-                List<IRType*> irParamTypes;
-                irParamTypes.add(irThisType);
-
-                // Create the remaining parameters of the callable,
-                // using a decl-ref specialized to the tagged union
-                // type (so that things like associated types are
-                // mapped to the correct witness value).
-                //
-                List<IRParam*> irParams;
-                for( auto paramDeclRef : getMembersOfType<ParamDecl>(context->astBuilder, callableDeclRef) )
-                {
-                    // TODO: need to handle `out` and `in out` here. Over all
-                    // there is a lot of duplication here with the existing logic
-                    // for emitting the signature of a `CallableDecl`, and we should
-                    // try to re-use that if at all possible.
-                    //
-                    auto irParamType = lowerType(context, getType(context->astBuilder, paramDeclRef));
-                    auto irParam = subBuilder->emitParam(irParamType);
-
-                    irParams.add(irParam);
-                    irParamTypes.add(irParamType);
-                }
-
-                auto irResultType = lowerType(context, getResultType(context->astBuilder, callableDeclRef));
-
-                auto irFuncType = subBuilder->getFuncType(
-                    irParamTypes,
-                    irResultType);
-                irFunc->setFullType(irFuncType);
-
-                // The first thing our function needs to do is extract the tag
-                // from the incoming `this` parameter.
-                //
-                auto irTagVal = subBuilder->emitExtractTaggedUnionTag(irThisParam);
-
-                // Next we want to emit a `switch` on the tag value, but before we
-                // do that we need to generate the code for each of the cases so that
-                // our `switch` has somewhere to branch to.
-                //
-                List<IRInst*> switchCaseOperands;
-
-                IRBlock* defaultLabel = nullptr;
-
-                for( Index ii = 0; ii < caseCount; ++ii )
-                {
-                    auto caseTag = subBuilder->getIntValue(irTagVal->getDataType(), ii);
-
-                    subBuilder->setInsertInto(irFunc);
-                    auto caseLabel = subBuilder->emitBlock();
-
-                    if(!defaultLabel)
-                        defaultLabel = caseLabel;
-
-                    switchCaseOperands.add(caseTag);
-                    switchCaseOperands.add(caseLabel);
-
-                    subBuilder->setInsertInto(caseLabel);
-
-                    // We need to look up the satisfying value for this interface
-                    // requirement on the witness table of the particular case value.
-                    //
-                    // We already have the witness table, and the requirement key is
-                    // just `irReqKey`.
-                    //
-                    auto caseWitnessTable = caseWitnessTables[ii];
-
-                    // The subtle bit here is determining the type we expect the
-                    // satisfying value to have, since that depends on the actual
-                    // type that is satisfying the requirement.
-                    //
-                    IRType* caseResultType = irResultType;
-                    IRType* caseFuncType = nullptr;
-                    auto caseFunc = subBuilder->emitLookupInterfaceMethodInst(
-                        caseFuncType,
-                        caseWitnessTable,
-                        irReqKey);
-
-                    // We are going to emit a `call` to the satisfying value
-                    // for the case type, so we will collect the arguments for that call.
-                    //
-                    List<IRInst*> caseArgs;
-
-                    // The `this` argument to the call will need to represent the
-                    // appropriate field of our tagged union.
-                    //
-                    IRType* caseThisType = (IRType*) irTaggedUnionType->getOperand(ii);
-                    auto caseThisArg = subBuilder->emitExtractTaggedUnionPayload(
-                        caseThisType,
-                        irThisParam, caseTag);
-                    caseArgs.add(caseThisArg);
-
-                    // The remaining arguments to the call will just be forwarded from
-                    // the parameters of the wrapper function.
-                    //
-                    // TODO: This would need to change if/when we started allowing `This` type
-                    // or associated-type parameters to be used at call sites where a tagged
-                    // union is used.
-                    //
-                    for( auto param : irParams )
-                    {
-                        caseArgs.add(param);
-                    }
-
-                    auto caseCall = subBuilder->emitCallInst(caseResultType, caseFunc, caseArgs);
-
-                    if( as<IRVoidType>(irResultType->getDataType()) )
-                    {
-                        subBuilder->emitReturn();
-                    }
-                    else
-                    {
-                        subBuilder->emitReturn(caseCall);
-                    }
-                }
-
-                // We will create a block to represent the supposedly-unreachable
-                // code that will run if no `case` matches.
-                //
-                subBuilder->setInsertInto(irFunc);
-                auto invalidLabel = subBuilder->emitBlock();
-                subBuilder->setInsertInto(invalidLabel);
-                subBuilder->emitUnreachable();
-
-                if(!defaultLabel) defaultLabel = invalidLabel;
-
-                // Now we have enough information to go back and emit the `switch` instruction
-                // into the entry block.
-                subBuilder->setInsertInto(entryBlock);
-                subBuilder->emitSwitch(
-                    irTagVal,       // value to `switch` on
-                    invalidLabel,   // `break` label (block after the `switch` statement ends)
-                    defaultLabel,   // `default` label (where to go if no `case` matches)
-                    switchCaseOperands.getCount(),
-                    switchCaseOperands.getBuffer());
-            }
-            else
-            {
-                // TODO: We need to handle other cases of interface requirements.
-                SLANG_UNEXPECTED("unexpceted interface requirement when generating tagged union witness table");
-                UNREACHABLE_RETURN(LoweredValInfo());
-            }
-
-            // Once we've generating a value to satisfying the requirement, we install
-            // it into the witness table for our tagged-union type.
-            //
-            getBuilder()->createWitnessTableEntry(irWitnessTable, irReqKey, irSatisfyingVal);
-        }
-        return LoweredValInfo::simple(irWitnessTable);
-    }
-
     LoweredValInfo visitDynamicSubtypeWitness(DynamicSubtypeWitness * /*val*/)
     {
         return LoweredValInfo::simple(nullptr);
     }
 
-    LoweredValInfo visitThisTypeSubtypeWitness(ThisTypeSubtypeWitness* val)
-    {
-        SLANG_UNUSED(val);
-        return LoweredValInfo::simple(context->thisTypeWitness);
-    }
-
     LoweredValInfo visitConjunctionSubtypeWitness(ConjunctionSubtypeWitness* val)
     {
         // A witness `W = X & Y & ...` will lower as a tuple of the sub-witnesses
@@ -1892,14 +1663,14 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
         // witness that `T : L & R`, so lower that first and expect it to be
         // a value of tuple type.
         //
-        auto conjunctionWitness = lowerSimpleVal(context, val->conjunctionWitness);
+        auto conjunctionWitness = lowerSimpleVal(context, val->getConjunctionWitness());
         auto conjunctionTupleType = as<IRTupleType>(conjunctionWitness->getDataType());
         SLANG_ASSERT(conjunctionTupleType);
 
         // The `ExtractFromConjunctionSubtypeWitness` also stores the index of
         // the witness/supertype we want in the conjunction `L & R`.
         //
-        auto indexInConjunction = val->indexInConjunction;
+        auto indexInConjunction = val->getIndexInConjunction();
 
         // We want to extract the appropriate element from the tuple based on
         // the index, but to know the type of the result we need to look up
@@ -1923,8 +1694,8 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     LoweredValInfo visitConstantIntVal(ConstantIntVal* val)
     {
-        auto type = lowerType(context, val->type);
-        return LoweredValInfo::simple(getBuilder()->getIntValue(type, val->value));
+        auto type = lowerType(context, val->getType());
+        return LoweredValInfo::simple(getBuilder()->getIntValue(type, val->getValue()));
     }
 
     IRFuncType* visitFuncType(FuncType* type)
@@ -1964,7 +1735,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     IRType* visitDeclRefType(DeclRefType* type)
     {
-        auto declRef = type->declRef;
+        auto declRef = type->getDeclRef();
         auto decl = declRef.getDecl();
 
         // Check for types with teh `__intrinsic_type` modifier.
@@ -1988,13 +1759,13 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
     IRType* visitBasicExpressionType(BasicExpressionType* type)
     {
         return getBuilder()->getBasicType(
-            type->baseType);
+            type->getBaseType());
     }
 
     IRType* visitVectorExpressionType(VectorExpressionType* type)
     {
-        auto elementType = lowerType(context, type->elementType);
-        auto elementCount = lowerSimpleVal(context, type->elementCount);
+        auto elementType = lowerType(context, type->getElementType());
+        auto elementCount = lowerSimpleVal(context, type->getElementCount());
 
         return getBuilder()->getVectorType(
             elementType,
@@ -2030,19 +1801,6 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
         }
     }
 
-    // Lower substitution args and collect them into a list of IR operands.
-    void _collectSubstitutionArgs(List<IRInst*>& operands, Substitutions* subst)
-    {
-        if (!subst) return;
-        _collectSubstitutionArgs(operands, subst->getOuter());
-        if (auto genSubst = as<GenericSubstitution>(subst))
-        {
-            for (auto arg : genSubst->getArgs())
-            {
-                operands.add(lowerVal(context, arg).val);
-            }
-        }
-    }
     // Lower a type where the type declaration being referenced is assumed
     // to be an intrinsic type, which can thus be lowered to a simple IR
     // type with the appropriate opcode.
@@ -2050,13 +1808,16 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
     {
         SLANG_ASSERT(getBuilder()->getInsertLoc().getMode() != IRInsertLoc::Mode::None);
 
-        auto intrinsicTypeModifier = type->declRef.getDecl()->findModifier<IntrinsicTypeModifier>();
+        auto intrinsicTypeModifier = type->getDeclRef().getDecl()->findModifier<IntrinsicTypeModifier>();
         SLANG_ASSERT(intrinsicTypeModifier);
         IROp op = IROp(intrinsicTypeModifier->irOp);
         List<IRInst*> operands;
         // If there are any substitutions attached to the declRef,
         // add them as operands of the IR type.
-        _collectSubstitutionArgs(operands, type->declRef.getSubst());
+        SubstitutionSet(type->getDeclRef()).forEachSubstitutionArg([&](Val* arg)
+            {
+                operands.add(lowerVal(context, arg).val);
+            });
         return getBuilder()->getType(
             op,
             static_cast<UInt>(operands.getCount()),
@@ -2095,7 +1856,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     IRType* visitExtractExistentialType(ExtractExistentialType* type)
     {
-        auto declRef = type->declRef;
+        auto declRef = type->getDeclRef();
         auto existentialType = lowerType(context, getType(context->astBuilder, declRef));
         IRInst* existentialVal = getSimpleVal(context, emitDeclRef(context, declRef, existentialType));
         return getBuilder()->emitExtractExistentialType(existentialVal);
@@ -2103,50 +1864,20 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     LoweredValInfo visitExtractExistentialSubtypeWitness(ExtractExistentialSubtypeWitness* witness)
     {
-        auto declRef = witness->declRef;
+        auto declRef = witness->getDeclRef();
         auto existentialType = lowerType(context, getType(context->astBuilder, declRef));
         IRInst* existentialVal = getSimpleVal(context, emitDeclRef(context, declRef, existentialType));
         return LoweredValInfo::simple(getBuilder()->emitExtractExistentialWitnessTable(existentialVal));
     }
 
-    LoweredValInfo visitTaggedUnionType(TaggedUnionType* type)
-    {
-        // A tagged union type will lower into an IR `union` over the cases,
-        // along with an IR `struct` with a field for the union and a tag.
-        // (Note: we are placing the tag after the payload to avoid padding
-        // in the case where the payload is more aligned than the tag)
-        //
-        // TODO: should we be lowering directly like this, or have
-        // an IR-level representation of tagged unions?
-        //
-
-        List<IRType*> irCaseTypes;
-        for(auto caseType : type->caseTypes)
-        {
-            auto irCaseType = lowerType(context, caseType);
-            irCaseTypes.add(irCaseType);
-        }
-
-        auto irType = getBuilder()->getTaggedUnionType(irCaseTypes);
-        if(!irType->findDecoration<IRLinkageDecoration>())
-        {
-            // We need a way for later passes to attach layout information
-            // to this type, so we will give it a mangled name here.
-            //
-            getBuilder()->addExportDecoration(
-                irType,
-                getMangledTypeName(context->astBuilder, type).getUnownedSlice());
-        }
-        return LoweredValInfo::simple(irType);
-    }
-
     LoweredValInfo visitExistentialSpecializedType(ExistentialSpecializedType* type)
     {
-        auto irBaseType = lowerType(context, type->baseType);
+        auto irBaseType = lowerType(context, type->getBaseType());
 
         List<IRInst*> slotArgs;
-        for(auto arg : type->args)
+        for (Index i = 0; i < type->getArgCount(); i++)
         {
+            auto arg = type->getArg(i);
             auto irArgVal = lowerSimpleVal(context, arg.val);
             slotArgs.add(irArgVal);
 
@@ -2173,13 +1904,13 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
         //
         if (context->thisType != nullptr)
             return LoweredValInfo::simple(context->thisType);
-        return emitDeclRef(context, type->interfaceDeclRef, getBuilder()->getTypeKind());
+        return emitDeclRef(context, makeDeclRef(type->getInterfaceDecl()), getBuilder()->getTypeKind());
     }
 
     LoweredValInfo visitAndType(AndType* type)
     {
-        auto left = lowerType(context, type->left);
-        auto right = lowerType(context, type->right);
+        auto left = lowerType(context, type->getLeft());
+        auto right = lowerType(context, type->getRight());
 
         auto irType = getBuilder()->getConjunctionType(left, right);
         return LoweredValInfo::simple(irType);
@@ -2187,11 +1918,12 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
 
     LoweredValInfo visitModifiedType(ModifiedType* astType)
     {
-        IRType* irBase = lowerType(context, astType->base);
+        IRType* irBase = lowerType(context, astType->getBase());
 
         List<IRAttr*> irAttrs;
-        for(auto astModifier : astType->modifiers)
+        for(Index i = 0; i < astType->getModifierCount(); i++)
         {
+            auto astModifier = astType->getModifier(i);
             IRAttr* irAttr = (IRAttr*) lowerSimpleVal(context, astModifier);
             if(irAttr)
                 irAttrs.add(irAttr);
@@ -2237,7 +1969,8 @@ LoweredValInfo lowerVal(
 {
     ValLoweringVisitor visitor;
     visitor.context = context;
-    return visitor.dispatch(val);
+    auto resolvedVal = val->resolve();
+    return visitor.dispatch(resolvedVal);
 }
 
 IRType* lowerType(
@@ -2786,8 +2519,8 @@ ParameterDirection getThisParamDirection(Decl* parentDecl, ParameterDirection de
 
 DeclRef<Decl> createDefaultSpecializedDeclRefImpl(IRGenContext* context, SemanticsVisitor* semantics, Decl* decl)
 {
-    DeclRef<Decl> declRef = context->astBuilder->getSpecializedDeclRef(
-        decl, createDefaultSubstitutions(context->astBuilder, semantics, decl));
+    DeclRef<Decl> declRef = createDefaultSubstitutionsIfNeeded(context->astBuilder, semantics,
+        makeDeclRef(decl));
     return declRef;
 }
 //
@@ -2808,7 +2541,7 @@ static Type* _findReplacementThisParamType(
         auto targetType = getTargetType(context->astBuilder, extensionDeclRef);
         if(auto targetDeclRefType = as<DeclRefType>(targetType))
         {
-            if(auto replacementType = _findReplacementThisParamType(context, targetDeclRefType->declRef))
+            if(auto replacementType = _findReplacementThisParamType(context, targetDeclRefType->getDeclRef()))
                 return replacementType;
         }
         return targetType;
@@ -2816,8 +2549,7 @@ static Type* _findReplacementThisParamType(
 
     if (auto interfaceDeclRef = parentDeclRef.as<InterfaceDecl>())
     {
-        auto thisType = context->astBuilder->create<ThisType>();
-        thisType->interfaceDeclRef = interfaceDeclRef;
+        auto thisType = DeclRefType::create(context->astBuilder, interfaceDeclRef.getDecl()->getThisTypeDecl());
         return thisType;
     }
 
@@ -2853,13 +2585,13 @@ Type* getThisParamTypeForCallable(
     IRGenContext*   context,
     DeclRef<Decl>   callableDeclRef)
 {
-    auto parentDeclRef = callableDeclRef.getParent(context->astBuilder);
+    auto parentDeclRef = callableDeclRef.getParent();
 
     if(auto subscriptDeclRef = parentDeclRef.as<SubscriptDecl>())
-        parentDeclRef = subscriptDeclRef.getParent(context->astBuilder);
+        parentDeclRef = subscriptDeclRef.getParent();
 
     if(auto genericDeclRef = parentDeclRef.as<GenericDecl>())
-        parentDeclRef = genericDeclRef.getParent(context->astBuilder);
+        parentDeclRef = genericDeclRef.getParent();
 
     return getThisParamTypeForContainer(context, parentDeclRef);
 }
@@ -2997,7 +2729,7 @@ void collectParameterLists(
     // The parameters introduced by any "parent" declarations
     // will need to come first, so we'll deal with that
     // logic here.
-    if( auto parentDeclRef = declRef.getParent(context->astBuilder) )
+    if( auto parentDeclRef = declRef.getParent() )
     {
         // Compute the mode to use when collecting parameters from
         // the outer declaration. The most important question here
@@ -3592,7 +3324,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
     {
         auto innerType = type;
         while (auto modifiedType = as<ModifiedType>(innerType))
-            innerType = modifiedType->base;
+            innerType = modifiedType->getBase();
         return innerType;
     }
 
@@ -3607,9 +3339,9 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
         }
         else if (auto vectorType = as<VectorExpressionType>(type))
         {
-            UInt elementCount = (UInt) getIntVal(vectorType->elementCount);
+            UInt elementCount = (UInt) getIntVal(vectorType->getElementCount());
 
-            auto irDefaultValue = getSimpleVal(context, getDefaultVal(vectorType->elementType));
+            auto irDefaultValue = getSimpleVal(context, getDefaultVal(vectorType->getElementType()));
 
             List<IRInst*> args;
             for(UInt ee = 0; ee < elementCount; ++ee)
@@ -3644,7 +3376,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
         }
         else if (auto declRefType = as<DeclRefType>(type))
         {
-            DeclRef<Decl> declRef = declRefType->declRef;
+            DeclRef<Decl> declRef = declRefType->getDeclRef();
             if (auto enumType = declRef.as<EnumDecl>())
             {
                 return LoweredValInfo::simple(getBuilder()->getIntValue(irType, 0));
@@ -3735,7 +3467,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
         }
         else if (auto vectorType = as<VectorExpressionType>(type))
         {
-            UInt elementCount = (UInt) getIntVal(vectorType->elementCount);
+            UInt elementCount = (UInt) getIntVal(vectorType->getElementCount());
 
             for (UInt ee = 0; ee < argCount; ++ee)
             {
@@ -3745,7 +3477,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
             }
             if(elementCount > argCount)
             {
-                auto irDefaultValue = getSimpleVal(context, getDefaultVal(vectorType->elementType));
+                auto irDefaultValue = getSimpleVal(context, getDefaultVal(vectorType->getElementType()));
                 for(UInt ee = argCount; ee < elementCount; ++ee)
                 {
                     args.add(irDefaultValue);
@@ -3781,7 +3513,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
         }
         else if (auto declRefType = as<DeclRefType>(type))
         {
-            DeclRef<Decl> declRef = declRefType->declRef;
+            DeclRef<Decl> declRef = declRefType->getDeclRef();
             if (auto aggTypeDeclRef = declRef.as<AggTypeDecl>())
             {
                 UInt argCounter = 0;
@@ -3896,19 +3628,19 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
         UNREACHABLE_RETURN(LoweredValInfo());
     }
 
-    void _lowerSubstitutionArg(IRGenContext* subContext, GenericSubstitution* subst, Decl* paramDecl, Index argIndex)
+    void _lowerSubstitutionArg(IRGenContext* subContext, GenericAppDeclRef* subst, Decl* paramDecl, Index argIndex)
     {
         SLANG_ASSERT(argIndex < subst->getArgs().getCount());
         auto argVal = lowerVal(subContext, subst->getArgs()[argIndex]);
         subContext->setValue(paramDecl, argVal);
     }
 
-    void _lowerSubstitutionEnv(IRGenContext* subContext, Substitutions* subst)
+    void _lowerSubstitutionEnv(IRGenContext* subContext, DeclRefBase* subst)
     {
         if(!subst) return;
-        _lowerSubstitutionEnv(subContext, subst->getOuter());
+        _lowerSubstitutionEnv(subContext, subst->getBase());
 
-        if (auto genSubst = as<GenericSubstitution>(subst))
+        if (auto genSubst = as<GenericAppDeclRef>(subst))
         {
             auto genDecl = genSubst->getGenericDecl();
 
@@ -3985,7 +3717,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
             IRGenContext* subContext = &subContextStorage;
             subContext->env = subEnv;
 
-            _lowerSubstitutionEnv(subContext, argExpr.getSubsts());
+            _lowerSubstitutionEnv(subContext, argExpr.getSubsts() ? argExpr.getSubsts().declRef : nullptr);
 
             addCallArgsForParam(subContext, paramType, paramDirection, argExpr.getExpr(), ioArgs, ioFixups);
 
@@ -4148,7 +3880,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
         {
             if(auto declRefType = as<DeclRefType>(e->type))
             {
-                if(declRefType->declRef.as<InterfaceDecl>())
+                if(declRefType->getDeclRef().as<InterfaceDecl>())
                 {
                     e = castExpr->valueArg;
                     continue;
@@ -4387,7 +4119,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
     {
         if( auto declaredSubtypeWitness = as<DeclaredSubtypeWitness>(subTypeWitness) )
         {
-            return extractField(superType, value, declaredSubtypeWitness->declRef);
+            return extractField(superType, value, declaredSubtypeWitness->getDeclRef());
         }
         else
         {
@@ -4414,7 +4146,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
         //
         if( auto declRefType = as<DeclRefType>(expr->type) )
         {
-            auto declRef = declRefType->declRef;
+            auto declRef = declRefType->getDeclRef();
             if( auto interfaceDeclRef = declRef.as<InterfaceDecl>() )
             {
                 // We have an expression that is "up-casting" some concrete value
@@ -4573,12 +4305,6 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
         UNREACHABLE_RETURN(LoweredValInfo());
     }
 
-    LoweredValInfo visitTaggedUnionTypeExpr(TaggedUnionTypeExpr* /*expr*/)
-    {
-        SLANG_UNIMPLEMENTED_X("tagged union type expression during code generation");
-        UNREACHABLE_RETURN(LoweredValInfo());
-    }
-
     LoweredValInfo visitThisTypeExpr(ThisTypeExpr* /*expr*/)
     {
         SLANG_UNIMPLEMENTED_X("this-type expression during code generation");
@@ -6676,7 +6402,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
 
         if (auto declRefType = as<DeclRefType>(type))
         {
-            if (declRefType->declRef.getDecl()->findModifier<PublicModifier>())
+            if (declRefType->getDeclRef().getDecl()->findModifier<PublicModifier>())
                 return true;
         }
         return false;
@@ -6690,7 +6416,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
     {
         auto subBuilder = subContext->irBuilder;
 
-        for(auto entry : astWitnessTable->requirementDictionary)
+        for(auto entry : astWitnessTable->getRequirementDictionary())
         {
             auto requiredMemberDecl = entry.key;
             auto satisfyingWitness = entry.value;
@@ -6787,7 +6513,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
             auto targetType = parentExtensionDecl->targetType;
             if(auto targetDeclRefType = as<DeclRefType>(targetType))
             {
-                if(auto targetInterfaceDeclRef = targetDeclRefType->declRef.as<InterfaceDecl>())
+                if(auto targetInterfaceDeclRef = targetDeclRefType->getDeclRef().as<InterfaceDecl>())
                 {
                     return LoweredValInfo::simple(getInterfaceRequirementKey(inheritanceDecl));
                 }
@@ -6815,7 +6541,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
 
         if(auto superDeclRefType = as<DeclRefType>(superType))
         {
-            if( superDeclRefType->declRef.as<StructDecl>() || superDeclRefType->declRef.as<ClassDecl>() )
+            if( superDeclRefType->getDeclRef().as<StructDecl>() || superDeclRefType->getDeclRef().as<ClassDecl>() )
             {
                 // TODO: the witness that a type inherits from a `struct`
                 // type should probably be a key that will be used for
@@ -7675,6 +7401,18 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
         return LoweredValInfo::simple(finishOuterGenerics(subBuilder, loweredTagType, outerGeneric));
     }
 
+    LoweredValInfo visitThisTypeDecl(ThisTypeDecl* decl)
+    {
+        auto interfaceType = ensureDecl(context, decl->parentDecl).val;
+        return LoweredValInfo::simple(context->irBuilder->getThisType(as<IRInterfaceType>(interfaceType)));
+    }
+
+    LoweredValInfo visitThisTypeConstraintDecl(ThisTypeConstraintDecl* decl)
+    {
+        SLANG_UNUSED(decl);
+        return LoweredValInfo();
+    }
+
     LoweredValInfo visitAggTypeDecl(AggTypeDecl* decl)
     {
         // Don't generate an IR `struct` for intrinsic types
@@ -7753,8 +7491,8 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
             auto superType = inheritanceDecl->base;
             if(auto superDeclRefType = as<DeclRefType>(superType))
             {
-                if (superDeclRefType->declRef.as<StructDecl>() ||
-                    superDeclRefType->declRef.as<ClassDecl>())
+                if (superDeclRefType->getDeclRef().as<StructDecl>() ||
+                    superDeclRefType->getDeclRef().as<ClassDecl>())
                 {
                     auto superKey = (IRStructKey*) getSimpleVal(context, ensureDecl(context, inheritanceDecl));
                     auto irSuperType = lowerType(context, superType.type);
@@ -7890,10 +7628,10 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
     void lowerDifferentiableAttribute(IRGenContext* subContext, IRInst* inst, DifferentiableAttribute* attr)
     {
         auto irDict = getBuilder()->addDifferentiableTypeDictionaryDecoration(inst);
-        for (auto& entry : attr->m_mapTypeToIDifferentiableWitness)
+        for (auto& entry : attr->getMapTypeToIDifferentiableWitness())
         {
             // Lower type and witness.
-            IRType* irType = lowerType(subContext, entry.value->sub);
+            IRType* irType = lowerType(subContext, entry.value->getSub());
             IRInst* irWitness = lowerVal(subContext, entry.value).val;
 
             SLANG_ASSERT(irType);
@@ -8028,7 +7766,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
             //
             if (auto declRefType = as<DeclRefType>(constraintDecl->sub.type))
             {
-                auto typeParamDeclVal = subContext->findLoweredDecl(declRefType->declRef.getDecl());
+                auto typeParamDeclVal = subContext->findLoweredDecl(declRefType->getDeclRef().getDecl());
                 SLANG_ASSERT(typeParamDeclVal && typeParamDeclVal->val);
                 subBuilder->addTypeConstraintDecoration(typeParamDeclVal->val, supType);
             }
@@ -8162,7 +7900,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
             {
                 if(auto targetDeclRefType = as<DeclRefType>(extensionAncestor->targetType))
                 {
-                    if(auto interfaceDeclRef = targetDeclRefType->declRef.as<InterfaceDecl>())
+                    if(auto interfaceDeclRef = targetDeclRefType->getDeclRef().as<InterfaceDecl>())
                     {
                         return emitOuterInterfaceGeneric(subContext, extensionAncestor, targetDeclRefType, leafDecl);
                     }
@@ -8608,9 +8346,12 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
         addNameHint(subContext, irFunc, decl);
         addLinkageDecoration(subContext, irFunc, decl);
 
-        if (auto differentialAttr = decl->findModifier<DifferentiableAttribute>())
+        if (decl->body)
         {
-            lowerDifferentiableAttribute(subContext, irFunc, differentialAttr);
+            if (auto differentialAttr = decl->findModifier<DifferentiableAttribute>())
+            {
+                lowerDifferentiableAttribute(subContext, irFunc, differentialAttr);
+            }
         }
 
         // Always force inline diff setter accessor to prevent downstream compiler from complaining
@@ -9375,7 +9116,7 @@ static void _addFlattenedTupleArgs(
 LoweredValInfo emitDeclRef(
     IRGenContext*           context,
     Decl*            decl,
-    Substitutions*   subst,
+    DeclRefBase*     subst,
     IRType*                 type)
 {
     const auto initialSubst = subst;
@@ -9383,27 +9124,28 @@ LoweredValInfo emitDeclRef(
 
     // We need to proceed by considering the specializations that
     // have been put in place.
+    subst = SubstitutionSet(subst).getInnerMostNodeWithSubstInfo();
 
     // If the declaration would not get wrapped in a `IRGeneric`,
     // even if it is nested inside of an AST `GenericDecl`, then
     // we should also ignore any generic substitutions.
     if(!canDeclLowerToAGeneric(decl))
     {
-        while(auto genericSubst = as<GenericSubstitution>(subst))
-            subst = genericSubst->getOuter();
+        while(auto genericSubst = SubstitutionSet(subst).findGenericAppDeclRef())
+            subst = genericSubst->getBase();
     }
 
     // In the simplest case, there is no specialization going
     // on, and the decl-ref turns into a reference to the
     // lowered IR value for the declaration.
-    if(!subst)
+    if(!SubstitutionSet(subst) || _isTrivialLookupFromInterfaceThis(context, subst))
     {
         LoweredValInfo loweredDecl = ensureDecl(context, decl);
         return loweredDecl;
     }
 
     // Otherwise, we look at the kind of substitution, and let it guide us.
-    if(auto genericSubst = as<GenericSubstitution>(subst))
+    if(auto genericSubst = as<GenericAppDeclRef>(subst))
     {
         // A generic substitution means we will need to output
         // a `specialize` instruction to specialize the generic.
@@ -9419,7 +9161,7 @@ LoweredValInfo emitDeclRef(
         LoweredValInfo genericVal = emitDeclRef(
             context,
             decl,
-            genericSubst->getOuter(),
+            genericSubst->getBase(),
             context->irBuilder->getGenericKind());
 
         // There's no reason to specialize something that maps to a NULL pointer.
@@ -9464,21 +9206,21 @@ LoweredValInfo emitDeclRef(
 
         return LoweredValInfo::simple(irSpecializedVal);
     }
-    else if(auto thisTypeSubst = as<ThisTypeSubstitution>(subst))
+    else if(auto thisTypeSubst = as<LookupDeclRef>(subst))
     {
-        if(decl == thisTypeSubst->interfaceDecl)
+        if( as<ThisTypeDecl>(decl))
         {
-            // This is a reference to the interface type itself,
-            // through the this-type substitution, so it is really
-            // a reference to the this-type.
-            return lowerType(context, thisTypeSubst->witness->sub);
+            // This is a reference to the ThisType from the interface,
+            // therefore we should just lower it as the sub type.
+            return lowerType(context, thisTypeSubst->getWitness()->getSub());
         }
 
         if(isInterfaceRequirement(decl))
         {
-            // Somebody is trying to look up an interface requirement
-            // "through" some concrete type. We need to lower this decl-ref
-            // as a lookup of the corresponding member in a witness table.
+            // If we reach here, somebody is trying to look up an interface
+            // requirement "through" some concrete type. We need to lower this
+            // decl-ref as a lookup of the corresponding member in a witness
+            // table.
             //
             // The witness table itself is referenced by the this-type
             // substitution, so we can just lower that.
@@ -9491,7 +9233,7 @@ LoweredValInfo emitDeclRef(
             // `ISomething<T>`. That is because we really care about the
             // witness table for the concrete type that conforms to `ISomething<Foo>`.
             //
-            auto irWitnessTable = lowerSimpleVal(context, thisTypeSubst->witness);
+            auto irWitnessTable = lowerSimpleVal(context, thisTypeSubst->getWitness());
             //
             // The key to use for looking up the interface member is
             // derived from the declaration.
@@ -9517,14 +9259,14 @@ LoweredValInfo emitDeclRef(
             // are lowered as generics, where the generic parameter represents
             // the `ThisType`.
             //
-            auto genericVal = emitDeclRef(context, decl, thisTypeSubst->getOuter(), context->irBuilder->getGenericKind());
+            auto genericVal = emitDeclRef(context, decl, thisTypeSubst->getBase(), context->irBuilder->getGenericKind());
             auto irGenericVal = getSimpleVal(context, genericVal);
 
             // In order to reference the member for a particular type, we
             // specialize the generic for that type.
             //
-            IRInst* irSubType = lowerType(context, thisTypeSubst->witness->sub);
-            IRInst* irSubTypeWitness = lowerSimpleVal(context, thisTypeSubst->witness);
+            IRInst* irSubType = lowerType(context, thisTypeSubst->getWitness()->getSub());
+            IRInst* irSubTypeWitness = lowerSimpleVal(context, thisTypeSubst->getWitness());
 
             IRInst* irSpecializeArgs[] = { irSubType, irSubTypeWitness };
             auto irSpecializedVal = context->irBuilder->emitSpecializeInst(
@@ -9550,7 +9292,7 @@ LoweredValInfo emitDeclRef(
     return emitDeclRef(
         context,
         declRef.getDecl(),
-        declRef.getSubst(),
+        declRef.declRefBase,
         type);
 }
 
@@ -9723,6 +9465,7 @@ RefPtr<IRModule> generateIRForTranslationUnit(
     TranslationUnitRequest* translationUnit)
 {
     SLANG_PROFILE;
+    SLANG_AST_BUILDER_RAII(astBuilder);
 
     auto session = translationUnit->getSession();
     auto compileRequest = translationUnit->compileRequest;
@@ -10082,6 +9825,8 @@ RefPtr<IRModule> generateIRForSpecializedComponentType(
     SpecializedComponentType*   componentType,
     DiagnosticSink*             sink)
 {
+    SLANG_AST_BUILDER_RAII(componentType->getLinkage()->getASTBuilder());
+
     SpecializedComponentTypeIRGenContext context;
     return context.process(componentType, sink);
 }
@@ -10135,6 +9880,8 @@ RefPtr<IRModule> generateIRForTypeConformance(
     Int conformanceIdOverride,
     DiagnosticSink* sink)
 {
+    SLANG_AST_BUILDER_RAII(typeConformance->getLinkage()->getASTBuilder());
+
     TypeConformanceIRGenContext context;
     return context.process(typeConformance, conformanceIdOverride, sink);
 }
@@ -10296,20 +10043,6 @@ IRTypeLayout* lowerTypeLayout(
         IRPointerTypeLayout::Builder builder(context->irBuilder); 
         return _lowerTypeLayoutCommon(context, &builder, ptrTypeLayout);
     }
-    else if( auto taggedUnionTypeLayout = as<TaggedUnionTypeLayout>(typeLayout) )
-    {
-        IRTaggedUnionTypeLayout::Builder builder(context->irBuilder, taggedUnionTypeLayout->tagOffset);
-
-        for( auto caseTypeLayout : taggedUnionTypeLayout->caseTypeLayouts )
-        {
-            builder.addCaseTypeLayout(
-                lowerTypeLayout(
-                    context,
-                    caseTypeLayout));
-        }
-
-        return _lowerTypeLayoutCommon(context, &builder, taggedUnionTypeLayout);
-    }
     else if( auto streamOutputTypeLayout = as<StreamOutputTypeLayout>(typeLayout) )
     {
         auto irElementTypeLayout = lowerTypeLayout(context, streamOutputTypeLayout->elementTypeLayout);
@@ -10453,6 +10186,9 @@ RefPtr<IRModule> TargetProgram::createIRModuleForLayout(DiagnosticSink* sink)
 
     auto program = getProgram();
     auto linkage = program->getLinkage();
+
+    SLANG_AST_BUILDER_RAII(linkage->getASTBuilder());
+
     auto session = linkage->getSessionImpl();
 
     SharedIRGenContext sharedContextStorage(
@@ -10550,16 +10286,6 @@ RefPtr<IRModule> TargetProgram::createIRModuleForLayout(DiagnosticSink* sink)
         builder->addLayoutDecoration(irFunc, irEntryPointLayout);
     }
 
-    for( auto taggedUnionTypeLayout : programLayout->taggedUnionTypeLayouts )
-    {
-        auto taggedUnionType = taggedUnionTypeLayout->getType();
-        auto irType = lowerType(context, taggedUnionType);
-
-        auto irTypeLayout = lowerTypeLayout(context, taggedUnionTypeLayout);
-
-        builder->addLayoutDecoration(irType, irTypeLayout);
-    }
-
     // Lets strip and run DCE here
     if (linkage->m_obfuscateCode)
     {
diff --git a/source/slang/slang-mangle.cpp b/source/slang/slang-mangle.cpp
index 4d94d5283..b27a45484 100644
--- a/source/slang/slang-mangle.cpp
+++ b/source/slang/slang-mangle.cpp
@@ -141,7 +141,7 @@ namespace Slang
     {
         if( auto constVal = as<ConstantIntVal>(val) )
         {
-            auto cVal = constVal->value;
+            auto cVal = constVal->getValue();
             if(cVal >= 0 && cVal <= 9 )
             {
                 emit(context, (UInt)cVal);
@@ -190,13 +190,13 @@ namespace Slang
 
         if( auto basicType = dynamicCast<BasicExpressionType>(type) )
         {
-            emitBaseType(context, basicType->baseType);
+            emitBaseType(context, basicType->getBaseType());
         }
         else if( auto vecType = dynamicCast<VectorExpressionType>(type) )
         {
             emitRaw(context, "v");
-            emitSimpleIntVal(context, vecType->elementCount);
-            emitType(context, vecType->elementType);
+            emitSimpleIntVal(context, vecType->getElementCount());
+            emitType(context, vecType->getElementType());
         }
         else if( auto matType = dynamicCast<MatrixExpressionType>(type) )
         {
@@ -208,11 +208,11 @@ namespace Slang
         }
         else if( auto namedType = dynamicCast<NamedExpressionType>(type) )
         {
-            emitType(context, getType(context->astBuilder, namedType->declRef));
+            emitType(context, getType(context->astBuilder, namedType->getDeclRef()));
         }
         else if( auto declRefType = dynamicCast<DeclRefType>(type) )
         {
-            emitQualifiedName(context, declRefType->declRef);
+            emitQualifiedName(context, declRefType->getDeclRef());
         }
         else if (auto arrType = dynamicCast<ArrayExpressionType>(type))
         {
@@ -220,19 +220,10 @@ namespace Slang
             emitSimpleIntVal(context, arrType->getElementCount());
             emitType(context, arrType->getElementType());
         }
-        else if( auto taggedUnionType = dynamicCast<TaggedUnionType>(type) )
-        {
-            emitRaw(context, "u");
-            for( auto caseType : taggedUnionType->caseTypes )
-            {
-                emitType(context, caseType);
-            }
-            emitRaw(context, "U");
-        }
         else if( auto thisType = dynamicCast<ThisType>(type) )
         {
             emitRaw(context, "t");
-            emitQualifiedName(context, thisType->interfaceDeclRef);
+            emitQualifiedName(context, thisType->getInterfaceDecl());
         }
         else if (const auto errorType = dynamicCast<ErrorType>(type))
         {
@@ -300,50 +291,50 @@ namespace Slang
             // "depth" (how many outer generics) and "index" (which
             // parameter are they at the specified depth).
             emitRaw(context, "K");
-            emitName(context, genericParamIntVal->declRef.getName());
+            emitName(context, genericParamIntVal->getDeclRef().getName());
         }
         else if( auto constantIntVal = dynamicCast<ConstantIntVal>(val) )
         {
             // TODO: need to figure out what prefix/suffix is needed
             // to allow demangling later.
             emitRaw(context, "k");
-            emit(context, (UInt) constantIntVal->value);
+            emit(context, (UInt) constantIntVal->getValue());
         }
         else if (auto funcCallIntVal = dynamicCast<FuncCallIntVal>(val))
         {
             emitRaw(context, "KC");
-            emit(context, funcCallIntVal->args.getCount());
-            emitName(context, funcCallIntVal->funcDeclRef.getName());
-            for (Index i = 0; i < funcCallIntVal->args.getCount(); i++)
-                emitVal(context, funcCallIntVal->args[i]);
+            emit(context, funcCallIntVal->getArgs().getCount());
+            emitName(context, funcCallIntVal->getFuncDeclRef().getName());
+            for (Index i = 0; i < funcCallIntVal->getArgs().getCount(); i++)
+                emitVal(context, funcCallIntVal->getArgs()[i]);
         }
         else if (auto lookupIntVal = dynamicCast<WitnessLookupIntVal>(val))
         {
             emitRaw(context, "KL");
-            emitVal(context, lookupIntVal->witness);
-            emitName(context, lookupIntVal->key->getName());
+            emitVal(context, lookupIntVal->getWitness());
+            emitName(context, lookupIntVal->getKey()->getName());
         }
         else if (const auto polynomialIntVal = dynamicCast<PolynomialIntVal>(val))
         {
             emitRaw(context, "KX");
-            emit(context, (UInt)polynomialIntVal->constantTerm);
-            emit(context, (UInt)polynomialIntVal->terms.getCount());
-            for (auto term : polynomialIntVal->terms)
+            emit(context, (UInt)polynomialIntVal->getConstantTerm());
+            emit(context, (UInt)polynomialIntVal->getTerms().getCount());
+            for (auto term : polynomialIntVal->getTerms())
             {
-                emit(context, (UInt)term->constFactor);
-                emit(context, (UInt)term->paramFactors.getCount());
-                for (auto factor : term->paramFactors)
+                emit(context, (UInt)term->getConstFactor());
+                emit(context, (UInt)term->getParamFactors().getCount());
+                for (auto factor : term->getParamFactors())
                 {
-                    emitVal(context, factor->param);
-                    emit(context, (UInt)factor->power);
+                    emitVal(context, factor->getParam());
+                    emit(context, (UInt)factor->getPower());
                 }
             }
         }
         else if (const auto typecastIntVal = dynamicCast<TypeCastIntVal>(val))
         {
             emitRaw(context, "KK");
-            emitVal(context, typecastIntVal->type);
-            emitVal(context, typecastIntVal->base);
+            emitVal(context, typecastIntVal->getType());
+            emitVal(context, typecastIntVal->getBase());
         }
         else
         {
@@ -355,7 +346,7 @@ namespace Slang
         ManglingContext*    context,
         DeclRef<Decl>       declRef)
     {
-        auto parentDeclRef = declRef.getParent(context->astBuilder);
+        auto parentDeclRef = declRef.getParent();
         auto parentGenericDeclRef = parentDeclRef.as<GenericDecl>();
         if( parentDeclRef )
         {
@@ -423,14 +414,14 @@ namespace Slang
             // There are two cases here: either we have specializations
             // in place for the parent generic declaration, or we don't.
 
-            auto subst = findInnerMostGenericSubstitution(declRef.getSubst());
-            if( subst && subst->getGenericDecl() == parentGenericDeclRef.getDecl())
+            auto substArgs = tryGetGenericArguments(SubstitutionSet(declRef), parentGenericDeclRef.getDecl());
+            if (substArgs.getCount())
             {
                 // This is the case where we *do* have substitutions.
                 emitRaw(context, "G");
-                UInt genericArgCount = subst->getArgs().getCount();
+                UInt genericArgCount = substArgs.getCount();
                 emit(context, genericArgCount);
-                for (auto aa : subst->getArgs())
+                for (auto aa : substArgs)
                 {
                     emitVal(context, aa);
                 }
@@ -441,7 +432,7 @@ namespace Slang
                 // information about the parameters of the generic here.
                 emitRaw(context, "g");
                 UInt genericParameterCount = 0;
-                for( auto mm : getMembers(context->astBuilder, parentGenericDeclRef) )
+                for( auto mm : getMembers(context->astBuilder, parentGenericDeclRef.as<ContainerDecl>()) )
                 {
                     if(mm.is<GenericTypeParamDecl>())
                     {
@@ -569,7 +560,7 @@ namespace Slang
             // mangling the generic and the inner entity
             emitRaw(context, "G");
 
-            SLANG_ASSERT(genericDecl.getSubst() == nullptr);
+            SLANG_ASSERT(SubstitutionSet(genericDecl).findGenericAppDeclRef() == nullptr);
 
             auto innerDecl = getInner(genericDecl);
 
@@ -591,6 +582,7 @@ namespace Slang
 
     static String getMangledName(ASTBuilder* astBuilder, DeclRef<Decl> const& declRef)
     {
+        SLANG_AST_BUILDER_RAII(astBuilder);
         ManglingContext context(astBuilder);
         mangleName(&context, declRef);
         return context.sb.produceString();
@@ -598,11 +590,15 @@ namespace Slang
 
     String getMangledName(ASTBuilder* astBuilder, DeclRefBase* declRef)
     {
+        SLANG_AST_BUILDER_RAII(astBuilder);
+
         return getMangledName(astBuilder, DeclRef<Decl>(declRef));
     }
 
     String getMangledName(ASTBuilder* astBuilder, Decl* decl)
     {
+        SLANG_AST_BUILDER_RAII(astBuilder);
+
         return getMangledName(astBuilder, makeDeclRef(decl));
     }
     
@@ -611,6 +607,7 @@ namespace Slang
         DeclRef<Decl> sub,
         DeclRef<Decl> sup)
     {
+        SLANG_AST_BUILDER_RAII(astBuilder);
         ManglingContext context(astBuilder);
         emitRaw(&context, "_SW");
         emitQualifiedName(&context, sub);
@@ -623,6 +620,7 @@ namespace Slang
         DeclRef<Decl> sub,
         Type* sup)
     {
+        SLANG_AST_BUILDER_RAII(astBuilder);
         // The mangled form for a witness that `sub`
         // conforms to `sup` will be named:
         //
@@ -640,6 +638,7 @@ namespace Slang
         Type* sub,
         Type* sup)
     {
+        SLANG_AST_BUILDER_RAII(astBuilder);
         // The mangled form for a witness that `sub`
         // conforms to `sup` will be named:
         //
@@ -654,6 +653,7 @@ namespace Slang
 
     String getMangledTypeName(ASTBuilder* astBuilder, Type* type)
     {
+        SLANG_AST_BUILDER_RAII(astBuilder);
         ManglingContext context(astBuilder);
         emitType(&context, type);
         return context.sb.produceString();
diff --git a/source/slang/slang-parameter-binding.cpp b/source/slang/slang-parameter-binding.cpp
index 47f370854..c0389d1cd 100644
--- a/source/slang/slang-parameter-binding.cpp
+++ b/source/slang/slang-parameter-binding.cpp
@@ -2064,7 +2064,7 @@ static RefPtr<TypeLayout> processEntryPointVaryingParameter(
     // otherwise they will include all of the above cases...
     else if( auto declRefType = as<DeclRefType>(type) )
     {
-        auto declRef = declRefType->declRef;
+        auto declRef = declRefType->getDeclRef();
 
         if (auto structDeclRef = declRef.as<StructDecl>())
         {
@@ -2777,7 +2777,7 @@ static RefPtr<EntryPointLayout> collectEntryPointParameters(
 
         // Any generic specialization applied to the entry-point function
         // must also be applied to its parameters.
-        paramDeclRef = context->getASTBuilder()->getSpecializedDeclRef(paramDeclRef.getDecl(), entryPointFuncDeclRef.getSubst());
+        paramDeclRef = context->getASTBuilder()->getMemberDeclRef(entryPointFuncDeclRef, paramDeclRef.getDecl());
 
         // When computing layout for an entry-point parameter,
         // we want to make sure that the layout context has access
@@ -3033,24 +3033,6 @@ struct CollectParametersVisitor : ComponentTypeVisitor
         // along.
         //
         visitChildren(specialized);
-
-        // While we are at it, we will also make note of any
-        // tagged-union types that were used as part of the
-        // specialization arguments, since we need to make
-        // sure that their layout information is computed
-        // and made available for IR code generation.
-        //
-        // Note: this isn't really the best place for this logic to sit,
-        // but it is the simplest place where we can collect all the tagged
-        // union types that get referenced by a program.
-        //
-        for( auto taggedUnionType : specialized->getTaggedUnionTypes() )
-        {
-            SLANG_ASSERT(taggedUnionType);
-            auto substType = taggedUnionType;
-            auto typeLayout = createTypeLayout(m_context->layoutContext, substType);
-            m_context->shared->programLayout->taggedUnionTypeLayouts.add(typeLayout);
-        }
     }
 
 
@@ -3755,6 +3737,8 @@ RefPtr<ProgramLayout> generateParameterBindings(
     TargetProgram*  targetProgram,
     DiagnosticSink* sink)
 {
+    SLANG_AST_BUILDER_RAII(targetProgram->getProgram()->getLinkage()->getASTBuilder());
+
     auto program = targetProgram->getProgram();
     auto targetReq = targetProgram->getTargetReq();
 
diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp
index cab01d585..4448a96e1 100644
--- a/source/slang/slang-parser.cpp
+++ b/source/slang/slang-parser.cpp
@@ -1323,10 +1323,9 @@ namespace Slang
     // parent link is set up correctly.
     static void AddMember(ContainerDecl* container, Decl* member)
     {
-        if (container && member)
+        if (container)
         {
-            member->parentDecl = container;
-            container->members.add(member);
+            container->addMember(member);
         }
     }
 
@@ -1334,7 +1333,7 @@ namespace Slang
     {
         if (scope)
         {
-            AddMember(scope->containerDecl, member);
+            scope->containerDecl->addMember(member);
         }
     }
 
@@ -2149,30 +2148,6 @@ namespace Slang
         }
         return typeExpr;
     }
-
-    static Expr* parseTaggedUnionType(Parser* parser)
-    {
-        TaggedUnionTypeExpr* taggedUnionType = parser->astBuilder->create<TaggedUnionTypeExpr>();
-
-        parser->ReadToken(TokenType::LParent);
-        while(!AdvanceIfMatch(parser, MatchedTokenType::Parentheses))
-        {
-            auto caseType = parser->ParseTypeExp();
-            taggedUnionType->caseTypes.add(caseType);
-
-            if(AdvanceIf(parser, TokenType::RParent))
-                break;
-
-            parser->ReadToken(TokenType::Comma);
-        }
-
-        return taggedUnionType;
-    }
-
-    static NodeBase* parseTaggedUnionType(Parser* parser, void* /*unused*/)
-    {
-        return parseTaggedUnionType(parser);
-    }
         /// Parse an expression of the form __fwd_diff(fn) where fn is an 
         /// identifier pointing to a function.
     static Expr* parseForwardDifferentiate(Parser* parser)
@@ -2234,19 +2209,6 @@ namespace Slang
         return parseDispatchKernel(parser);
     }
 
-        /// Parse a `This` type expression
-    static Expr* parseThisTypeExpr(Parser* parser)
-    {
-        ThisTypeExpr* expr = parser->astBuilder->create<ThisTypeExpr>();
-        expr->scope = parser->currentScope;
-        return expr;
-    }
-
-    static NodeBase* parseThisTypeExpr(Parser* parser, void* /*userData*/)
-    {
-        return parseThisTypeExpr(parser);
-    }
-
     // (a,b,c) style tuples, curently unused
 #if 0
     static Expr* parseTupleTypeExpr(Parser* parser)
@@ -2459,22 +2421,6 @@ namespace Slang
             typeSpec.expr = createDeclRefType(parser, decl);
             return typeSpec;
         }
-        // TODO: This case would not be needed if we had the
-        // code below dispatch into `parseAtomicExpr`, which
-        // already includes logic for keyword lookup.
-        //
-        // Leaving this case here for now to avoid breaking anything.
-        //
-        else if(AdvanceIf(parser, "__TaggedUnion"))
-        {
-            typeSpec.expr = parseTaggedUnionType(parser);
-            return typeSpec;
-        }
-        else if(AdvanceIf(parser, "This"))
-        {
-            typeSpec.expr = parseThisTypeExpr(parser);
-            return typeSpec;
-        }
         // Uncomment should we decide to enable (a,b,c) tuple types
         // else if(parser->LookAheadToken(TokenType::LParent))
         // {
@@ -3170,7 +3116,7 @@ namespace Slang
 
     static NodeBase* parseInterfaceDecl(Parser* parser, void* /*userData*/)
     {
-        InterfaceDecl* decl = parser->astBuilder->create<InterfaceDecl>();
+        InterfaceDecl* decl = parser->astBuilder->createInterfaceDecl(parser->tokenReader.peekLoc());
         parser->FillPosition(decl);
 
         AdvanceIf(parser, TokenType::CompletionRequest);
@@ -4082,6 +4028,8 @@ namespace Slang
 
     void Parser::parseSourceFile(ModuleDecl* program)
     {
+        SLANG_AST_BUILDER_RAII(astBuilder);
+
         if (outerScope)
         {
             currentScope = outerScope;
@@ -4328,6 +4276,7 @@ namespace Slang
                     parser->astBuilder,
                     nullptr, // no semantics visitor available yet
                     staticMemberExpr->name,
+                    aggTypeDecl,
                     declRef);
 
                 if (!lookupResult.isValid() || lookupResult.isOverloaded())
@@ -6252,7 +6201,7 @@ namespace Slang
                     // Need to get the basic type, so we can fit to underlying type
                     if (auto basicExprType = as<BasicExpressionType>(intLit->type.type))
                     {
-                        value = _fixIntegerLiteral(basicExprType->baseType, value, nullptr, nullptr);
+                        value = _fixIntegerLiteral(basicExprType->getBaseType(), value, nullptr, nullptr);
                     }
 
                     newLiteral->value = value;
@@ -6910,14 +6859,12 @@ namespace Slang
         // !!!!!!!!!!!!!!!!!!!!!!! Expr !!!!!!!!!!!!!!!!!!!!!!!!!!!
 
         _makeParseExpr("this",  parseThisExpr),
-        _makeParseExpr("This",  parseThisTypeExpr),
         _makeParseExpr("true",  parseTrueExpr),
         _makeParseExpr("false", parseFalseExpr),
         _makeParseExpr("nullptr", parseNullPtrExpr),
         _makeParseExpr("none", parseNoneExpr),
         _makeParseExpr("try",     parseTryExpr),
         _makeParseExpr("no_diff", parseTreatAsDifferentiableExpr),
-        _makeParseExpr("__TaggedUnion", parseTaggedUnionType),
         _makeParseExpr("__fwd_diff", parseForwardDifferentiate),
         _makeParseExpr("__bwd_diff", parseBackwardDifferentiate),
         _makeParseExpr("fwd_diff", parseForwardDifferentiate),
diff --git a/source/slang/slang-reflection-api.cpp b/source/slang/slang-reflection-api.cpp
index 7a79e9fcd..9f83d325d 100644
--- a/source/slang/slang-reflection-api.cpp
+++ b/source/slang/slang-reflection-api.cpp
@@ -269,11 +269,14 @@ SLANG_API SlangResult spReflectionUserAttribute_GetArgumentValueInt(SlangReflect
     if (!userAttr) return SLANG_E_INVALID_ARG;
     if (index >= (unsigned int)userAttr->args.getCount()) return SLANG_E_INVALID_ARG;
 
-    NodeBase* val = nullptr;
-    if (userAttr->intArgVals.tryGetValue(index, val))
+    if (userAttr->intArgVals.getCount() > (Index)index)
     {
-        *rs = (int)as<ConstantIntVal>(val)->value;
-        return 0;
+        auto intVal = as<ConstantIntVal>(userAttr->intArgVals[index]);
+        if (intVal)
+        {
+            *rs = (int)intVal->getValue();
+            return 0;
+        }
     }
     return SLANG_E_INVALID_ARG;
 }
@@ -387,7 +390,7 @@ SLANG_API SlangTypeKind spReflectionType_GetKind(SlangReflectionType* inType)
     }
     else if( auto declRefType = as<DeclRefType>(type) )
     {
-        const auto& declRef = declRefType->declRef;
+        const auto& declRef = declRefType->getDeclRef();
         if(declRef.is<StructDecl>() )
         {
             return SLANG_TYPE_KIND_STRUCT;
@@ -429,7 +432,7 @@ SLANG_API unsigned int spReflectionType_GetFieldCount(SlangReflectionType* inTyp
 
     if(auto declRefType = as<DeclRefType>(type))
     {
-        auto declRef = declRefType->declRef;
+        auto declRef = declRefType->getDeclRef();
         if( auto structDeclRef = declRef.as<StructDecl>())
         {
             return (unsigned int)getFields(
@@ -452,7 +455,7 @@ SLANG_API SlangReflectionVariable* spReflectionType_GetFieldByIndex(SlangReflect
 
     if(auto declRefType = as<DeclRefType>(type))
     {
-        auto declRef = declRefType->declRef;
+        auto declRef = declRefType->getDeclRef();
         if( auto structDeclRef = declRef.as<StructDecl>())
         {
             auto fields = getFields(
@@ -476,7 +479,7 @@ SLANG_API size_t spReflectionType_GetElementCount(SlangReflectionType* inType)
     }
     else if( auto vectorType = as<VectorExpressionType>(type))
     {
-        return (size_t) getIntVal(vectorType->elementCount);
+        return (size_t) getIntVal(vectorType->getElementCount());
     }
 
     return 0;
@@ -493,15 +496,15 @@ SLANG_API SlangReflectionType* spReflectionType_GetElementType(SlangReflectionTy
     }
     else if( auto parameterGroupType = as<ParameterGroupType>(type))
     {
-        return convert(parameterGroupType->elementType);
+        return convert(parameterGroupType->getElementType());
     }
     else if (auto structuredBufferType = as<HLSLStructuredBufferTypeBase>(type))
     {
-        return convert(structuredBufferType->elementType);
+        return convert(structuredBufferType->getElementType());
     }
     else if( auto vectorType = as<VectorExpressionType>(type))
     {
-        return convert(vectorType->elementType);
+        return convert(vectorType->getElementType());
     }
     else if( auto matrixType = as<MatrixExpressionType>(type))
     {
@@ -543,7 +546,7 @@ SLANG_API unsigned int spReflectionType_GetColumnCount(SlangReflectionType* inTy
     }
     else if(auto vectorType = as<VectorExpressionType>(type))
     {
-        return (unsigned int) getIntVal(vectorType->elementCount);
+        return (unsigned int) getIntVal(vectorType->getElementCount());
     }
     else if( const auto basicType = as<BasicExpressionType>(type) )
     {
@@ -564,12 +567,12 @@ SLANG_API SlangScalarType spReflectionType_GetScalarType(SlangReflectionType* in
     }
     else if(auto vectorType = as<VectorExpressionType>(type))
     {
-        type = vectorType->elementType;
+        type = vectorType->getElementType();
     }
 
     if(auto basicType = as<BasicExpressionType>(type))
     {
-        switch (basicType->baseType)
+        switch (basicType->getBaseType())
         {
 #define CASE(BASE, TAG) \
         case BaseType::BASE: return SLANG_SCALAR_TYPE_##TAG
@@ -606,7 +609,7 @@ SLANG_API unsigned int spReflectionType_GetUserAttributeCount(SlangReflectionTyp
     if (!type) return 0;
     if (auto declRefType = as<DeclRefType>(type))
     {
-        return getUserAttributeCount(declRefType->declRef.getDecl());
+        return getUserAttributeCount(declRefType->getDeclRef().getDecl());
     }
     return 0;
 }
@@ -616,7 +619,7 @@ SLANG_API SlangReflectionUserAttribute* spReflectionType_GetUserAttribute(SlangR
     if (!type) return 0;
     if (auto declRefType = as<DeclRefType>(type))
     {
-        return getUserAttributeByIndex(declRefType->declRef.getDecl(), index);
+        return getUserAttributeByIndex(declRefType->getDeclRef().getDecl(), index);
     }
     return 0;
 }
@@ -626,10 +629,10 @@ SLANG_API SlangReflectionUserAttribute* spReflectionType_FindUserAttributeByName
     if (!type) return 0;
     if (auto declRefType = as<DeclRefType>(type))
     {
-        ASTBuilder* astBuilder = declRefType->getASTBuilder();
+        ASTBuilder* astBuilder = declRefType->getASTBuilderForReflection();
         auto globalSession = astBuilder->getGlobalSession();
 
-        return findUserAttributeByName(globalSession, declRefType->declRef.getDecl(), name);
+        return findUserAttributeByName(globalSession, declRefType->getDeclRef().getDecl(), name);
     }
     return 0;
 }
@@ -714,7 +717,7 @@ SLANG_API char const* spReflectionType_GetName(SlangReflectionType* inType)
 
     if( auto declRefType = as<DeclRefType>(type) )
     {
-        auto declRef = declRefType->declRef;
+        auto declRef = declRefType->getDeclRef();
 
         // Don't return a name for auto-generated anonymous types
         // that represent `cbuffer` members, etc.
@@ -778,13 +781,13 @@ SLANG_API SlangReflectionType* spReflectionType_GetResourceResultType(SlangRefle
 
     if (auto textureType = as<TextureTypeBase>(type))
     {
-        return convert(textureType->elementType);
+        return convert(textureType->getElementType());
     }
 
     // TODO: need a better way to handle this stuff...
 #define CASE(TYPE, SHAPE, ACCESS)                                                       \
     else if(as<TYPE>(type)) do {                                                      \
-        return convert(as<TYPE>(type)->elementType);                            \
+        return convert(as<TYPE>(type)->getElementType());                            \
     } while(0)
 
     // TODO: structured buffer needs to expose type layout!
@@ -1132,7 +1135,7 @@ SLANG_API SlangInt spReflectionType_getSpecializedTypeArgCount(SlangReflectionTy
     auto specializedType = as<ExistentialSpecializedType>(type);
     if(!specializedType) return 0;
 
-    return specializedType->args.getCount();
+    return specializedType->getArgCount();
 }
 
 SLANG_API SlangReflectionType* spReflectionType_getSpecializedTypeArgType(SlangReflectionType* inType, SlangInt index)
@@ -1144,9 +1147,9 @@ SLANG_API SlangReflectionType* spReflectionType_getSpecializedTypeArgType(SlangR
     if(!specializedType) return nullptr;
 
     if(index < 0) return nullptr;
-    if(index >= specializedType->args.getCount()) return nullptr;
+    if(index >= specializedType->getArgCount()) return nullptr;
 
-    auto argType = as<Type>(specializedType->args[index].val);
+    auto argType = as<Type>(specializedType->getArg(index).val);
     return convert(argType);
 }
 
@@ -1405,7 +1408,7 @@ namespace Slang
     {
         if(auto declRefType = as<DeclRefType>(type))
         {
-            if(declRefType->declRef.as<InterfaceDecl>())
+            if(declRefType->getDeclRef().as<InterfaceDecl>())
             {
                 return declRefType;
             }
diff --git a/source/slang/slang-serialize-ast-type-info.h b/source/slang/slang-serialize-ast-type-info.h
index c28c8a6d6..351b6f519 100644
--- a/source/slang/slang-serialize-ast-type-info.h
+++ b/source/slang/slang-serialize-ast-type-info.h
@@ -39,20 +39,82 @@ struct SerialTypeInfo<SyntaxClass<T>>
     }
 };
 
+// MatrixCoord can just go as is
+template <>
+struct SerialTypeInfo<MatrixCoord> : SerialIdentityTypeInfo<MatrixCoord> {};
+
+inline void serializePointerValue(SerialWriter* writer, Val* ptrValue, SerialIndex* outSerial)
+{
+    if (ptrValue)
+        ptrValue = ptrValue->resolve();
+    *(SerialIndex*)outSerial = writer->addPointer(ptrValue);
+}
+
+inline void deserializePointerValue(SerialReader* reader, const SerialIndex* inSerial, void* outPtr, Val* unusedForResolution)
+{
+    SLANG_UNUSED(unusedForResolution);
+
+    auto val = reader->getPointer(*(const SerialIndex*)inSerial).dynamicCast<Val>();
+    *(Val**)outPtr = val;
+    if (val)
+    {
+        SLANG_ASSERT(as<Val>(val));
+        PostSerializationFixUp fixup;
+        fixup.kind = PostSerializationFixUpKind::ValPtr;
+        fixup.addressToModify = outPtr;
+        reader->getFixUps().add(fixup);
+    }
+}
 
 template <typename T>
 struct SerialTypeInfo<DeclRef<T>> : public SerialTypeInfo<DeclRefBase*> {};
 
-// MatrixCoord can just go as is
+// ValNodeOperand
 template <>
-struct SerialTypeInfo<MatrixCoord> : SerialIdentityTypeInfo<MatrixCoord> {};
+struct SerialTypeInfo<ValNodeOperand>
+{
+    typedef ValNodeOperand NativeType;
+    struct SerialType
+    {
+        int8_t kind;
+        int64_t val;
+    };
+    enum { SerialAlignment = SLANG_ALIGN_OF(SerialType) };
+
+    static void toSerial(SerialWriter* writer, const void* native, void* serial)
+    {
+        auto& src = *(const NativeType*)native;
+        auto& dst = *(SerialType*)serial;
+        dst.kind = int8_t(src.kind);
+        if (src.kind == ValNodeOperandKind::ConstantValue)
+            dst.val = src.values.intOperand;
+        else if (src.kind == ValNodeOperandKind::ValNode)
+            serializePointerValue(writer, (Val*)src.values.nodeOperand, (SerialIndex*)&dst.val);
+        else
+            serializePointerValue(writer, src.values.nodeOperand, (SerialIndex*)&dst.val);
+    }
+    static void toNative(SerialReader* reader, const void* serial, void* native)
+    {
+        auto& dst = *(NativeType*)native;
+        auto& src = *(const SerialType*)serial;
+
+        // Initialize
+        dst = NativeType();
+        dst.kind = ValNodeOperandKind(src.kind);
+        if (dst.kind == ValNodeOperandKind::ConstantValue)
+            dst.values.intOperand = int64_t(src.val);
+        else if (dst.kind == ValNodeOperandKind::ValNode)
+            deserializePointerValue(reader, (SerialIndex*)&src.val, (Val**)&dst.values.nodeOperand, (Val*)nullptr);
+        else
+            deserializePointerValue(reader, (SerialIndex*)&src.val, &dst.values.nodeOperand, (NodeBase*)nullptr);
+    }
+};
 
 // LookupResultItem
 SLANG_VALUE_TYPE_INFO(LookupResultItem)
 // QualType
 SLANG_VALUE_TYPE_INFO(QualType)
 
-
 // LookupResult
 template <>
 struct SerialTypeInfo<LookupResult>
@@ -151,10 +213,6 @@ struct SerialTypeInfo<Modifiers>
     }
 };
 
-// ASTNodeType
-template <>
-struct SerialTypeInfo<ASTNodeType> : public SerialConvertTypeInfo<ASTNodeType, uint16_t> {};
-
 // LookupResultItem_Breadcrumb::ThisParameterMode
 template <>
 struct SerialTypeInfo<LookupResultItem_Breadcrumb::ThisParameterMode> : public SerialConvertTypeInfo<LookupResultItem_Breadcrumb::ThisParameterMode, uint8_t> {};
@@ -170,6 +228,7 @@ struct SerialTypeInfo<RequirementWitness::Flavor> : public SerialConvertTypeInfo
 // RequirementWitness
 SLANG_VALUE_TYPE_INFO(RequirementWitness)
 
+
 } // namespace Slang
 
 #endif
diff --git a/source/slang/slang-serialize-container.cpp b/source/slang/slang-serialize-container.cpp
index c75237896..293535b02 100644
--- a/source/slang/slang-serialize-container.cpp
+++ b/source/slang/slang-serialize-container.cpp
@@ -475,10 +475,6 @@ static List<ExtensionDecl*>& _getCandidateExtensionList(
                     // Set the sourceLocReader before doing de-serialize, such can lookup the remapped sourceLocs
                     reader.getExtraObjects().set(sourceLocReader);
 
-                    // Go through all of the AST nodes
-                    // 1) Set the ASTBuilder on Type nodes
-                    
-
                     // TODO(JS):
                     // If modules can have more complicated relationships (like a two modules can refer to symbols
                     // from each other), then we can make this work by
@@ -492,12 +488,14 @@ static List<ExtensionDecl*>& _getCandidateExtensionList(
                     // For now if we assume a module can only access symbols from another module, and not the reverse.
                     // So we just need to deserialize and we are done
                     SLANG_RETURN_ON_FAIL(reader.deserializeObjects());
-
+                    
                     // Get the root node. It's at index 1 (0 is the null value).
                     astRootNode = reader.getPointer(SerialIndex(1)).dynamicCast<NodeBase>();
 
-                    // 2) Add the extensions to the module mapTypeToCandidateExtensions cache
-                    // 3) We need to fix the callback pointers for parsing
+                    // Go through all AST nodes:
+                    // 1) Add the extensions to the module mapTypeToCandidateExtensions cache
+                    // 2) We need to fix the callback pointers for parsing
+                    // 3) Register all `Val`s to the ASTBuilder's deduplication map.
 
                     {
                         ModuleDecl* moduleDecl = as<ModuleDecl>(astRootNode);
@@ -505,6 +503,8 @@ static List<ExtensionDecl*>& _getCandidateExtensionList(
                         // Maps from keyword name name to index in (syntaxParseInfos)
                         // Will be filled in lazily if needed (for SyntaxDecl setup)
                         Dictionary<Name*, Index> syntaxKeywordDict;
+                        
+                        OrderedDictionary<Val*, List<Val**>> valUses;
 
                         // Get the parse infos
                         const auto syntaxParseInfos = getSyntaxParseInfos();
@@ -512,21 +512,18 @@ static List<ExtensionDecl*>& _getCandidateExtensionList(
 
                         for (auto& obj : reader.getObjects())
                         {
+
                             if (obj.m_kind == SerialTypeKind::NodeBase)
                             {
                                 NodeBase* nodeBase = (NodeBase*)obj.m_ptr;
                                 SLANG_ASSERT(nodeBase);
 
-                                if (Type* type = dynamicCast<Type>(nodeBase))
-                                {
-                                    type->_setASTBuilder(astBuilder);
-                                }
-                                else if (ExtensionDecl* extensionDecl = dynamicCast<ExtensionDecl>(nodeBase))
+                                if (ExtensionDecl* extensionDecl = dynamicCast<ExtensionDecl>(nodeBase))
                                 {
                                     if (auto targetDeclRefType = as<DeclRefType>(extensionDecl->targetType))
                                     {
                                         // Attach our extension to that type as a candidate...
-                                        if (auto aggTypeDeclRef = targetDeclRefType->declRef.as<AggTypeDecl>())
+                                        if (auto aggTypeDeclRef = targetDeclRefType->getDeclRef().as<AggTypeDecl>())
                                         {
                                             auto aggTypeDecl = aggTypeDeclRef.getDecl();
 
@@ -567,6 +564,47 @@ static List<ExtensionDecl*>& _getCandidateExtensionList(
                                         syntaxDecl->parseUserData = const_cast<ReflectClassInfo*>(syntaxDecl->syntaxClass.classInfo);
                                     }
                                 }
+                                else if (Val* val = dynamicCast<Val>(nodeBase))
+                                {
+                                    valUses[val] = List<Val**>();
+                                }
+                            }
+                        }
+                        // Go through fixup locations and deduplicate Vals.
+                        // This is needed because we currently the same Val can be serialized multiple times
+                        // in different modules. If we have a type defined in Module A and used in Module B,
+                        // then both serialized Module A and Module B will contain a Type Val object that refers to A.
+                        // When we load B, we should resolve those type references to the existing Type val instead.
+                        // This step can be avoided if we can run deduplication while deserializing, which
+                        // requires a different way of handling Val objects.
+                        for (auto fixup : reader.getFixUps())
+                        {
+                            if (fixup.kind == PostSerializationFixUpKind::ValPtr)
+                            {
+                                auto list = valUses.tryGetValue(*(Val**)fixup.addressToModify);
+                                if (list)
+                                    list->add((Val**)fixup.addressToModify);
+                            }
+                        }
+                        SLANG_AST_BUILDER_RAII(astBuilder);
+                        for (auto& valUseList : valUses)
+                        {
+                            auto val = valUseList.key;
+                            auto desc = val->getDesc();
+                            astBuilder->m_cachedNodes.tryGetValueOrAdd(desc, val);
+                        }
+                        for (auto& valUseList : valUses)
+                        {
+                            auto val = valUseList.key;
+                            auto newVal = val->resolve();
+                            if (val != newVal)
+                            {
+                                astBuilder->m_cachedNodes[val->getDesc()] = newVal;
+                                for (auto use : valUseList.value)
+                                {
+                                    if (*use != newVal)
+                                        *use = newVal;
+                                }
                             }
                         }
                     }
diff --git a/source/slang/slang-serialize-type-info.h b/source/slang/slang-serialize-type-info.h
index 971d45197..c4b20c5b9 100644
--- a/source/slang/slang-serialize-type-info.h
+++ b/source/slang/slang-serialize-type-info.h
@@ -3,6 +3,7 @@
 #define SLANG_SERIALIZE_TYPE_INFO_H
 
 #include "slang-serialize.h"
+
 namespace Slang {
 
 /* For the serialization system to work we need to defined how native types are represented in the serialized format.
@@ -87,7 +88,6 @@ struct SerialTypeInfo<float> : public SerialBasicTypeInfo<float> {};
 template <>
 struct SerialTypeInfo<double> : public SerialBasicTypeInfo<double> {};
 
-
 // Fixed arrays
 
 template <typename T, size_t N>
@@ -154,9 +154,26 @@ struct SerialTypeInfo<T, typename std::enable_if<std::is_enum<T>::value>::type>
     : public SerialIdentityTypeInfo<T>
 {};
 
+class Val;
+
 // Pointer
-// Could handle different pointer base types with some more template magic here, but instead went with Pointer type to keep
-// things simpler.
+
+template<typename T, typename sfinae = typename std::enable_if<!IsBaseOf<Val, T>::Value>::type>
+void serializePointerValue(SerialWriter* writer, T* ptrValue, SerialIndex* outSerial)
+{
+    static_assert(!IsBaseOf<Val, T>::Value);
+    *(SerialIndex*)outSerial = writer->addPointer(ptrValue);
+}
+
+template<typename T, typename sfinae = typename std::enable_if<!IsBaseOf<Val, T>::Value>::type>
+void deserializePointerValue(SerialReader* reader, SerialIndex* inSerial, void* outPtr, T* unusedForResolution)
+{
+    static_assert(!IsBaseOf<Val, T>::Value);
+
+    SLANG_UNUSED(unusedForResolution);
+    *(T**)outPtr = reader->getPointer(*(const SerialIndex*)inSerial).dynamicCast<T>();
+}
+
 template <typename T>
 struct SerialTypeInfo<T*>
 {
@@ -166,11 +183,13 @@ struct SerialTypeInfo<T*>
 
     static void toSerial(SerialWriter* writer, const void* inNative, void* outSerial)
     {
-        *(SerialType*)outSerial = writer->addPointer(*(T**)inNative);
+        auto ptrToWrite = *(T**)inNative;
+        serializePointerValue(writer, ptrToWrite, (SerialIndex*)outSerial);
     }
+
     static void toNative(SerialReader* reader, const void* inSerial, void* outNative)
     {
-        *(T**)outNative = reader->getPointer(*(const SerialType*)inSerial).dynamicCast<T>();
+        deserializePointerValue(reader, (SerialIndex*)inSerial, outNative, (T*)nullptr);
     }
 };
 
@@ -257,74 +276,8 @@ struct SerialTypeInfo<String>
 };
 
 // Dictionary
-template <typename KEY, typename VALUE>
-struct SerialTypeInfo<Dictionary<KEY, VALUE>>
-{
-    typedef Dictionary<KEY, VALUE> NativeType;
-    struct SerialType
-    {
-        SerialIndex keys;            ///< Index an array
-        SerialIndex values;          ///< Index an array
-    };
-
-    typedef typename SerialTypeInfo<KEY>::SerialType KeySerialType;
-    typedef typename SerialTypeInfo<VALUE>::SerialType ValueSerialType;
-
-    enum { SerialAlignment = SLANG_ALIGN_OF(SerialIndex) };
-
-    static void toSerial(SerialWriter* writer, const void* native, void* serial)
-    {
-        auto& src = *(const NativeType*)native;
-        auto& dst = *(SerialType*)serial;
-
-        List<KeySerialType> keys;
-        List<ValueSerialType> values;
-
-        Index count = Index(src.getCount());
-        keys.setCount(count);
-        values.setCount(count);
-
-        if (writer->getFlags() & SerialWriter::Flag::ZeroInitialize)
-        {
-            ::memset(keys.getBuffer(), 0, count * sizeof(KeySerialType));
-            ::memset(values.getBuffer(), 0, count * sizeof(ValueSerialType));
-        }
-
-        Index i = 0;
-        for (const auto& pair : src)
-        {
-            SerialTypeInfo<KEY>::toSerial(writer, &pair.key, &keys[i]);
-            SerialTypeInfo<VALUE>::toSerial(writer, &pair.value, &values[i]);
-            i++;
-        }
-
-        // When we add the array it is already converted to a serializable type, so add as SerialArray
-        dst.keys = writer->addSerialArray<KEY>(keys.getBuffer(), count);
-        dst.values = writer->addSerialArray<VALUE>(values.getBuffer(), count);
-    }
-    static void toNative(SerialReader* reader, const void* serial, void* native)
-    {
-        auto& src = *(const SerialType*)serial;
-        auto& dst = *(NativeType*)native;
-
-        // Clear it
-        dst = NativeType();
-
-        List<KEY> keys;
-        List<VALUE> values;
-
-        reader->getArray(src.keys, keys);
-        reader->getArray(src.values, values);
-
-        SLANG_ASSERT(keys.getCount() == values.getCount());
-
-        const Index count = keys.getCount();
-        for (Index i = 0; i < count; ++i)
-        {
-            dst.add(keys[i], values[i]);
-        }
-    }
-};
+// Note: We leave out SerialTypeInfo specialization for Dictionary, because
+// it does not have determinstic ordering.
 
 // OrderedDictionary
 template <typename KEY, typename VALUE>
diff --git a/source/slang/slang-serialize-types.cpp b/source/slang/slang-serialize-types.cpp
index 6c4512b1d..a091a2850 100644
--- a/source/slang/slang-serialize-types.cpp
+++ b/source/slang/slang-serialize-types.cpp
@@ -48,7 +48,8 @@ struct ByteReader
         const int numPrefixBytes = encodeUnicodePointToUTF8(len, prefixBytes);
         const Index baseIndex = stringTable.getCount();
 
-        stringTable.setCount(baseIndex + numPrefixBytes + len);
+        auto newCount = baseIndex + numPrefixBytes + len;
+        stringTable.growToCount(newCount);
 
         char* dst = stringTable.begin() + baseIndex;
 
diff --git a/source/slang/slang-serialize.cpp b/source/slang/slang-serialize.cpp
index 2e8d6c6ba..1f5b6942d 100644
--- a/source/slang/slang-serialize.cpp
+++ b/source/slang/slang-serialize.cpp
@@ -2,6 +2,7 @@
 #include "slang-serialize.h"
 
 #include "slang-ast-base.h"
+#include "slang-ast-builder.h"
 
 namespace Slang {
 
@@ -204,14 +205,14 @@ bool SerialClasses::isOk() const
 
 
 SerialClasses::SerialClasses():
-    m_arena(2048)
+    m_arena(2097152)
 {
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! SerialWriter  !!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 SerialWriter::SerialWriter(SerialClasses* classes, SerialFilter* filter, Flags flags)
-    : m_arena(2048)
+    : m_arena(2097152)
     , m_classes(classes)
     , m_filter(filter)
     , m_flags(flags)
diff --git a/source/slang/slang-serialize.h b/source/slang/slang-serialize.h
index cc617034d..ce7bfa87b 100644
--- a/source/slang/slang-serialize.h
+++ b/source/slang/slang-serialize.h
@@ -211,6 +211,17 @@ protected:
    void* m_objects[Index(SerialExtraType::CountOf)];
 };
 
+enum class PostSerializationFixUpKind
+{
+    ValPtr,
+};
+
+struct PostSerializationFixUp
+{
+    PostSerializationFixUpKind kind;
+    void* addressToModify;
+};
+
 /* This class is the interface used by toNative implementations to recreate a type. */
 class SerialReader : public RefObject
 {
@@ -240,6 +251,8 @@ public:
         /// Get the entries list
     const List<const Entry*>& getEntries() const { return m_entries; }
 
+    List<PostSerializationFixUp>& getFixUps() { return m_fixUps; }
+
         /// Access the objects list
         /// NOTE that if a SerialObject holding a RefObject and needs to be kept in scope, add the RefObject* via addScope
     List<SerialPointer>& getObjects() { return m_objects; }
@@ -277,6 +290,8 @@ protected:
 
     SerialObjectFactory* m_objectFactory;
     SerialClasses* m_classes;           ///< Information used to deserialize 
+
+    List<PostSerializationFixUp> m_fixUps;
 };
 
 // ---------------------------------------------------------------------------
diff --git a/source/slang/slang-syntax.cpp b/source/slang/slang-syntax.cpp
index 227e468d6..ae44e0c70 100644
--- a/source/slang/slang-syntax.cpp
+++ b/source/slang/slang-syntax.cpp
@@ -284,14 +284,14 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
     {
         if(auto declaredSubtypeWitness = as<DeclaredSubtypeWitness>(subtypeWitness))
         {
-            if(auto inheritanceDeclRef = declaredSubtypeWitness->declRef.as<InheritanceDecl>())
+            if(auto inheritanceDeclRef = declaredSubtypeWitness->getDeclRef().as<InheritanceDecl>())
             {
                 // A conformance that was declared as part of an inheritance clause
                 // will have built up a dictionary of the satisfying declarations
                 // for each of its requirements.
                 RequirementWitness requirementWitness;
                 auto witnessTable = inheritanceDeclRef.getDecl()->witnessTable;
-                if(witnessTable && witnessTable->requirementDictionary.tryGetValue(requirementKey, requirementWitness))
+                if(witnessTable && witnessTable->getRequirementDictionary().tryGetValue(requirementKey, requirementWitness))
                 {
                     // The `inheritanceDeclRef` has substitutions applied to it that
                     // *aren't* present in the `requirementWitness`, because it was
@@ -338,7 +338,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
                     // So, in order to get the *right* end result, we need to apply
                     // the substitutions from the inheritance decl-ref to the witness.
                     //
-                    requirementWitness = requirementWitness.specialize(astBuilder, inheritanceDeclRef.getSubst());
+                    requirementWitness = requirementWitness.specialize(astBuilder, SubstitutionSet(inheritanceDeclRef));
 
                     return requirementWitness;
                 }
@@ -346,17 +346,17 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
         }
         else if (auto transitiveTypeWitness = as<TransitiveSubtypeWitness>(subtypeWitness))
         {
-            if (auto declaredSubtypeWitnessMidToSup = as<DeclaredSubtypeWitness>(transitiveTypeWitness->midToSup))
+            if (auto declaredSubtypeWitnessMidToSup = as<DeclaredSubtypeWitness>(transitiveTypeWitness->getMidToSup()))
             {
-                auto midKey = declaredSubtypeWitnessMidToSup->declRef;
-                auto midWitness = tryLookUpRequirementWitness(astBuilder, as<SubtypeWitness>(transitiveTypeWitness->subToMid), midKey.getDecl());
+                auto midKey = declaredSubtypeWitnessMidToSup->getDeclRef();
+                auto midWitness = tryLookUpRequirementWitness(astBuilder, as<SubtypeWitness>(transitiveTypeWitness->getSubToMid()), midKey.getDecl());
                 if (midWitness.getFlavor() == RequirementWitness::Flavor::witnessTable)
                 {
                     auto table = midWitness.getWitnessTable();
                     RequirementWitness result;
-                    if (table->requirementDictionary.tryGetValue(requirementKey, result))
+                    if (table->getRequirementDictionary().tryGetValue(requirementKey, result))
                     {
-                        result = result.specialize(astBuilder, midKey.getSubst());
+                        result = result.specialize(astBuilder, SubstitutionSet(midKey));
                     }
                     return result;
                 }
@@ -364,15 +364,32 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
         }
         else if (auto extractFromConjunctionTypeWitness = as<ExtractFromConjunctionSubtypeWitness>(subtypeWitness))
         {
-            if (auto conjunctionTypeWitness = as<ConjunctionSubtypeWitness>(extractFromConjunctionTypeWitness->conjunctionWitness))
+            if (auto conjunctionTypeWitness = as<ConjunctionSubtypeWitness>(extractFromConjunctionTypeWitness->getConjunctionWitness()))
             {
                 auto componentWitness = as<SubtypeWitness>(
                     conjunctionTypeWitness->getComponentWitness(
-                        extractFromConjunctionTypeWitness->indexInConjunction));
+                        extractFromConjunctionTypeWitness->getIndexInConjunction()));
 
                 return tryLookUpRequirementWitness(astBuilder, componentWitness, requirementKey);
             }
         }
+        
+        // If we are looking for `ThisType`, just return subtype.
+        if (as<ThisTypeDecl>(requirementKey))
+        {
+            RequirementWitness result;
+            result.m_flavor = RequirementWitness::Flavor::val;
+            result.m_val = subtypeWitness->getSub();
+            return result;
+        }
+        // If we are looking for `ThisTypeConstraint`, just return the witness itself.
+        if (as<ThisTypeConstraintDecl>(requirementKey))
+        {
+            RequirementWitness result;
+            result.m_flavor = RequirementWitness::Flavor::val;
+            result.m_val = subtypeWitness;
+            return result;
+        }
         // TODO: should handle the transitive case here too
 
         return RequirementWitness();
@@ -384,125 +401,8 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
 
     void WitnessTable::add(Decl* decl, RequirementWitness const& witness)
     {
-        SLANG_ASSERT(!requirementDictionary.containsKey(decl));
-
-        requirementDictionary.add(decl, witness);
-    }
-
-    //
-
-    static Type* ExtractGenericArgType(Val* val)
-    {
-        auto type = as<Type>(val);
-        SLANG_RELEASE_ASSERT(type);
-        return type;
-    }
-
-    static IntVal* ExtractGenericArgInteger(Val* val)
-    {
-        auto intVal = as<IntVal>(val);
-        SLANG_RELEASE_ASSERT(intVal);
-        return intVal;
-    }
-
-    DeclRef<Decl> createDefaultSubstitutionsIfNeeded(
-        ASTBuilder*     astBuilder,
-        SemanticsVisitor* semantics,
-        DeclRef<Decl>   declRef)
-    {
-        // It is possible that `declRef` refers to a generic type,
-        // but does not specify arguments for its generic parameters.
-        // (E.g., this happens when referring to a generic type from
-        // within its own member functions). To handle this case,
-        // we will construct a default specialization at the use
-        // site if needed.
-        //
-        // This same logic should also apply to declarations nested
-        // more than one level inside of a generic (e.g., a `typdef`
-        // inside of a generic `struct`).
-        //
-        // Similarly, it needs to work for multiple levels of
-        // nested generics.
-        //
-
-        // First, we collect all the generic parents.
-        ShortList<GenericDecl*> genericParents;
-        Decl* dd = declRef.getDecl();
-        for (;;)
-        {
-            Decl* childDecl = dd;
-            Decl* parentDecl = dd->parentDecl;
-            if (!parentDecl)
-                break;
-
-            dd = parentDecl;
-
-            if (auto genericParentDecl = as<GenericDecl>(parentDecl))
-            {
-                // Don't specialize any parameters of a generic.
-                if (childDecl != genericParentDecl->inner)
-                    break;
-                genericParents.add(genericParentDecl);
-            }
-        }
-
-
-        Substitutions* outerSubst = nullptr;
-        for (Index i = genericParents.getCount()-1; i>=0; i--)
-        {
-            Decl* childDecl = genericParents[i]->inner;
-            Decl* parentDecl = genericParents[i];
-
-            if(auto genericParentDecl = as<GenericDecl>(parentDecl))
-            {
-                // Don't specialize any parameters of a generic.
-                if(childDecl != genericParentDecl->inner)
-                    break;
-
-                // We have a generic ancestor, but do we have an substitutions for it?
-                GenericSubstitution* foundSubst = nullptr;
-                for(auto s = declRef.getSubst(); s; s = s->getOuter())
-                {
-                    auto genSubst = as<GenericSubstitution>(s);
-                    if(!genSubst)
-                        continue;
-
-                    if(genSubst->getGenericDecl() != genericParentDecl)
-                        continue;
-
-                    // Okay, we found a matching substitution,
-                    // so we just grab the args from the matching subst instead.
-                    foundSubst = genSubst;
-                    if (foundSubst->getOuter() != outerSubst)
-                    {
-                        foundSubst = astBuilder->getOrCreateGenericSubstitution(
-                            outerSubst, foundSubst->getGenericDecl(), foundSubst->getArgs());
-                    }
-
-                    break;
-                }
-
-                if(!foundSubst)
-                {
-                    Substitutions* newSubst = createDefaultSubstitutionsForGeneric(
-                        astBuilder,
-                        semantics,
-                        genericParentDecl,
-                        outerSubst);
-                    outerSubst = newSubst;
-                }
-                else
-                {
-                    outerSubst = foundSubst;
-                }
-            }
-        }
-
-        if(!outerSubst)
-            return declRef;
-
-        int diff = 0;
-        return declRef.substituteImpl(astBuilder, outerSubst, &diff);
+        m_requirements.add(KeyValuePair<Decl*, RequirementWitness>(decl, witness));
+        m_requirementDictionary.add(decl, witness);
     }
 
     // TODO: need to figure out how to unify this with the logic
@@ -511,245 +411,73 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
         ASTBuilder*     astBuilder,
         DeclRef<Decl>   declRef)
     {
-        declRef = createDefaultSubstitutionsIfNeeded(astBuilder, nullptr, declRef);
-
         if (auto builtinMod = declRef.getDecl()->findModifier<BuiltinTypeModifier>())
         {
-            auto type = astBuilder->getOrCreate<BasicExpressionType>(builtinMod->tag);
-            type->declRef = declRef;
+            // Always create builtin types in global AST builder.
+            if (astBuilder->getSharedASTBuilder()->getInnerASTBuilder() != astBuilder)
+                return DeclRefType::create(astBuilder->getSharedASTBuilder()->getInnerASTBuilder(), declRef);
+
+            declRef = createDefaultSubstitutionsIfNeeded(astBuilder, nullptr, declRef);
+            auto type = astBuilder->getOrCreate<BasicExpressionType>(declRef.declRefBase);
             return type;
         }
         else if (auto magicMod = declRef.getDecl()->findModifier<MagicTypeModifier>())
         {
-            GenericSubstitution* subst = nullptr;
-            for(auto s = declRef.getSubst(); s; s = s->getOuter())
-            {
-                if(auto genericSubst = as<GenericSubstitution>(s))
-                {
-                    subst = genericSubst;
-                    break;
-                }
-            }
+            // Always create builtin types in global AST builder.
+            if (astBuilder->getSharedASTBuilder()->getInnerASTBuilder() != astBuilder)
+                return DeclRefType::create(astBuilder->getSharedASTBuilder()->getInnerASTBuilder(), declRef);
 
-            if (magicMod->magicName == "SamplerState")
-            {
-                auto type = astBuilder->getOrCreate<SamplerStateType>(SamplerStateFlavor(magicMod->tag));
-                type->declRef = declRef;
-                return type;
-            }
-            else if (magicMod->magicName == "Vector")
-            {
-                SLANG_ASSERT(subst && subst->getArgs().getCount() == 2);
-                auto vecType = astBuilder->getOrCreate<VectorExpressionType>(ExtractGenericArgType(subst->getArgs()[0]), ExtractGenericArgInteger(subst->getArgs()[1]));
-                vecType->declRef = declRef;
-                vecType->elementType = ExtractGenericArgType(subst->getArgs()[0]);
-                vecType->elementCount = ExtractGenericArgInteger(subst->getArgs()[1]);
-                return vecType;
-            }
-            else if (magicMod->magicName == "ArrayType")
-            {
-                SLANG_ASSERT(subst && subst->getArgs().getCount() == 2);
-                auto vecType = astBuilder->getOrCreate<ArrayExpressionType>(ExtractGenericArgType(subst->getArgs()[0]), ExtractGenericArgInteger(subst->getArgs()[1]));
-                vecType->declRef = declRef;
-                return vecType;
-            }
-            else if (magicMod->magicName == "Matrix")
+            declRef = createDefaultSubstitutionsIfNeeded(astBuilder, nullptr, declRef);
+            auto classInfo = astBuilder->findSyntaxClass(magicMod->magicName.getUnownedSlice());
+            if (!classInfo.classInfo)
             {
-                SLANG_ASSERT(subst && subst->getArgs().getCount() == 3);
-                auto matType = astBuilder->getOrCreate<MatrixExpressionType>(
-                    ExtractGenericArgType(subst->getArgs()[0]),
-                    ExtractGenericArgInteger(subst->getArgs()[1]),
-                    ExtractGenericArgInteger(subst->getArgs()[2]));
-                matType->declRef = declRef;
-                return matType;
+                SLANG_UNEXPECTED("unhandled type");
             }
-            else if (magicMod->magicName == "TensorViewType")
-            {
-                SLANG_ASSERT(subst && subst->getArgs().getCount() == 1);
-                auto vecType = astBuilder->getOrCreate<TensorViewType>(ExtractGenericArgType(subst->getArgs()[0]));
-                vecType->declRef = declRef;
-                return vecType;
-            }
-            else if (magicMod->magicName == "Texture")
-            {
-                SLANG_ASSERT(subst && subst->getArgs().getCount() >= 1);
-                auto textureTag = TextureFlavor(magicMod->tag);
-                Val* sampleCount = nullptr;
-                if (textureTag.isMultisample())
+            ValNodeDesc nodeDesc = {};
+            nodeDesc.type = (ASTNodeType)classInfo.classInfo->m_classId;
+            nodeDesc.operands.add(ValNodeOperand(declRef));
+            nodeDesc.init();
+            NodeBase* type = astBuilder->_getOrCreateImpl(nodeDesc, [&]()
                 {
-                    if (subst->getArgs().getCount() >= 2)
-                        sampleCount = ExtractGenericArgInteger(subst->getArgs().getLast());
-                }
-                auto textureType = astBuilder->getOrCreate<TextureType>(
-                    textureTag,
-                    ExtractGenericArgType(subst->getArgs()[0]),
-                    sampleCount);
-                textureType->declRef = declRef;
-                return textureType;
-            }
-            else if (magicMod->magicName == "TextureSampler")
-            {
-                SLANG_ASSERT(subst && subst->getArgs().getCount() >= 1);
-                auto textureType = astBuilder->getOrCreate<TextureSamplerType>(
-                    TextureFlavor(magicMod->tag),
-                    ExtractGenericArgType(subst->getArgs()[0]));
-                textureType->declRef = declRef;
-                return textureType;
-            }
-            else if (magicMod->magicName == "GLSLImageType")
-            {
-                SLANG_ASSERT(subst && subst->getArgs().getCount() >= 1);
-                auto textureType = astBuilder->getOrCreate<GLSLImageType>(
-                    TextureFlavor(magicMod->tag),
-                    ExtractGenericArgType(subst->getArgs()[0]));
-                textureType->declRef = declRef;
-                return textureType;
-            }
-            else if (magicMod->magicName == "FeedbackType")
+                    auto resultNode = as<DeclRefType>(classInfo.createInstance(astBuilder));
+                    resultNode->setOperands(declRef);
+                    return resultNode;
+                });
+            if (!type)
             {
-                SLANG_ASSERT(subst == nullptr);
-                auto type = astBuilder->getOrCreateWithDefaultCtor<FeedbackType>(magicMod->tag);
-                type->declRef = declRef;
-                type->kind = FeedbackType::Kind(magicMod->tag);
-                return type;
+                SLANG_UNEXPECTED("constructor failure");
             }
 
-            // TODO: eventually everything should follow this pattern,
-            // and we can drive the dispatch with a table instead
-            // of this ridiculously slow `if` cascade.
-
-        #define CASE(n, T)                                              \
-            else if (magicMod->magicName == #n)                         \
-            {                                                           \
-                auto type = astBuilder->getOrCreateWithDefaultCtor<T>(  \
-                    declRef.getDecl(), declRef.getSubst()); \
-                type->declRef = declRef;                                \
-                return type;                                            \
-            }
-
-            CASE(HLSLInputPatchType, HLSLInputPatchType)
-            CASE(HLSLOutputPatchType, HLSLOutputPatchType)
-
-        #undef CASE
-
-        #define CASE(n, T)                                                                            \
-            else if (magicMod->magicName == #n)                                                       \
-            {                                                                                         \
-                SLANG_ASSERT(subst && subst->getArgs().getCount() == 1);                                   \
-                auto type =                                                                           \
-                    astBuilder->getOrCreateWithDefaultCtor<T>(ExtractGenericArgType(subst->getArgs()[0])); \
-                type->elementType = ExtractGenericArgType(subst->getArgs()[0]);                            \
-                type->declRef = declRef;                                                              \
-                return type;                                                                          \
-            }
-
-            CASE(ConstantBuffer, ConstantBufferType)
-            CASE(TextureBuffer, TextureBufferType)
-            CASE(ParameterBlockType, ParameterBlockType)
-            CASE(GLSLInputParameterGroupType, GLSLInputParameterGroupType)
-            CASE(GLSLOutputParameterGroupType, GLSLOutputParameterGroupType)
-            CASE(GLSLShaderStorageBufferType, GLSLShaderStorageBufferType)
-
-            CASE(HLSLStructuredBufferType, HLSLStructuredBufferType)
-            CASE(HLSLRWStructuredBufferType, HLSLRWStructuredBufferType)
-            CASE(HLSLRasterizerOrderedStructuredBufferType, HLSLRasterizerOrderedStructuredBufferType)
-            CASE(HLSLAppendStructuredBufferType, HLSLAppendStructuredBufferType)
-            CASE(HLSLConsumeStructuredBufferType, HLSLConsumeStructuredBufferType)
-
-            CASE(HLSLPointStreamType, HLSLPointStreamType)
-            CASE(HLSLLineStreamType, HLSLLineStreamType)
-            CASE(HLSLTriangleStreamType, HLSLTriangleStreamType)
-
-            #undef CASE
-
-            // "magic" builtin types which have no generic parameters
-            #define CASE(n,T)													\
-                else if(magicMod->magicName == #n) {		     				\
-                    auto type = astBuilder->getOrCreate<T>();					\
-                    type->declRef = declRef;									\
-                    return type;												\
-                }
-
-            CASE(HLSLByteAddressBufferType, HLSLByteAddressBufferType)
-            CASE(HLSLRWByteAddressBufferType, HLSLRWByteAddressBufferType)
-            CASE(HLSLRasterizerOrderedByteAddressBufferType, HLSLRasterizerOrderedByteAddressBufferType)
-            CASE(UntypedBufferResourceType, UntypedBufferResourceType)
-
-            CASE(GLSLInputAttachmentType, GLSLInputAttachmentType)
-
-            #undef CASE
-
-            else
+            auto declRefType = dynamicCast<DeclRefType>(type);
+            if (!declRefType)
             {
-                auto classInfo = astBuilder->findSyntaxClass(magicMod->magicName.getUnownedSlice());
-                if (!classInfo.classInfo)
-                {
-                    SLANG_UNEXPECTED("unhandled type");
-                }
-
-                NodeBase* type = classInfo.createInstance(astBuilder);
-                if (!type)
-                {
-                    SLANG_UNEXPECTED("constructor failure");
-                }
-
-                auto declRefType = dynamicCast<DeclRefType>(type);
-                if (!declRefType)
-                {
-                    SLANG_UNEXPECTED("expected a declaration reference type");
-                }
-                declRefType->declRef = declRef;
-                return declRefType;
+                SLANG_UNEXPECTED("expected a declaration reference type");
             }
+            return declRefType;
+        }
+        else if (as<ThisTypeDecl>(declRef.getDecl()) && as<DirectDeclRef>(declRef.declRefBase))
+        {
+            declRef = createDefaultSubstitutionsIfNeeded(astBuilder, nullptr, declRef);
+
+            return astBuilder->getOrCreate<ThisType>(declRef.declRefBase);
         }
         else
         {
+            declRef = createDefaultSubstitutionsIfNeeded(astBuilder, nullptr, declRef);
+
             return astBuilder->getOrCreate<DeclRefType>(declRef.declRefBase);
         }
     }
 
     //
 
-    GenericSubstitution* findInnerMostGenericSubstitution(Substitutions* subst)
+    Val::OperandView<Val> findInnerMostGenericArgs(SubstitutionSet subst)
     {
-        for(Substitutions* s = subst; s; s = s->getOuter())
-        {
-            if(auto genericSubst = as<GenericSubstitution>(s))
-                return genericSubst;
-        }
-        return nullptr;
-    }
-
-   
-    // DeclRefBase
-
-    Type* DeclRefBase::substitute(ASTBuilder* astBuilder, Type* type) const
-    {
-        // Note that type can be nullptr, and so this function can return nullptr (although only correctly when no substitutions) 
-
-        // No substitutions? Easy.
-        if (!substitutions)
-            return type;
-
-        SLANG_ASSERT(type);
-
-        // Otherwise we need to recurse on the type structure
-        // and apply substitutions where it makes sense
-        return Slang::as<Type>(type->substitute(astBuilder, substitutions));
-    }
-
-    DeclRefBase* DeclRefBase::substitute(ASTBuilder* astBuilder, DeclRefBase* declRef) const
-    {
-        if(!substitutions)
-            return declRef;
-
-        int diff = 0;
-        return declRef->substituteImpl(astBuilder, substitutions, &diff);
-    }
-
-    SubstExpr<Expr> DeclRefBase::substitute(ASTBuilder* /* astBuilder*/, Expr* expr) const
-    {
-        return SubstExpr<Expr>(expr, substitutions);
+        if (!subst.declRef)
+            return Val::OperandView<Val>();
+        if (auto genApp = subst.findGenericAppDeclRef())
+            return genApp->getArgs();
+        return Val::OperandView<Val>();
     }
 
     SubstExpr<Expr> substituteExpr(SubstitutionSet const& substs, Expr* expr)
@@ -764,7 +492,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
 
         int diff = 0;
         auto declRefBase = declRef.substituteImpl(astBuilder, substs, &diff);
-        return astBuilder->getSpecializedDeclRef<Decl>(declRefBase.getDecl(), declRefBase.getSubst());
+        return declRefBase;
     }
 
     Type* substituteType(SubstitutionSet const& substs, ASTBuilder* astBuilder, Type* type)
@@ -790,332 +518,13 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
         return nullptr;
     }
 
-    Substitutions* specializeSubstitutionsShallow(
-        ASTBuilder*             astBuilder, 
-        Substitutions*   substToSpecialize,
-        Substitutions*   substsToApply,
-        Substitutions*   restSubst,
-        int*                    ioDiff)
-    {
-        SLANG_ASSERT(substToSpecialize);
-        return substToSpecialize->applySubstitutionsShallow(astBuilder, substsToApply, restSubst, ioDiff);
-    }
-
-    // Construct new substitutions to apply to a declaration,
-    // based on a provided substitution set to be applied
-    Substitutions* specializeSubstitutions(
-        ASTBuilder*             astBuilder,
-        Decl*                   declToSpecialize,
-        Substitutions*   substsToSpecialize,
-        Substitutions*   substsToApply,
-        int*                    ioDiff)
-    {
-        // No declaration? Then nothing to specialize.
-        if(!declToSpecialize)
-            return nullptr;
-
-        // No (remaining) substitutions to apply? Then we are done.
-        if(!substsToApply)
-            return substsToSpecialize;
-
-        // Walk the hierarchy of the declaration to determine what specializations might apply.
-        // We assume that the `substsToSpecialize` must be aligned with the ancestor
-        // hierarchy of `declToSpecialize` such that if, e.g., the `declToSpecialize` is
-        // nested directly in a generic, then `substToSpecialize` will either start with
-        // the corresponding `GenericSubstitution` or there will be *no* generic substitutions
-        // corresponding to that decl.
-        for(Decl* ancestorDecl = declToSpecialize; ancestorDecl; ancestorDecl = ancestorDecl->parentDecl)
-        {
-            if(auto ancestorGenericDecl = as<GenericDecl>(ancestorDecl))
-            {
-                // The declaration is nested inside a generic.
-                // Does it already have a specialization for that generic?
-                if(auto specGenericSubst = as<GenericSubstitution>(substsToSpecialize))
-                {
-                    if(specGenericSubst->getGenericDecl() == ancestorGenericDecl)
-                    {
-                        // Yes. We have an existing specialization, so we will
-                        // keep one matching it in place.
-                        int diff = 0;
-                        auto restSubst = specializeSubstitutions(
-                            astBuilder,
-                            ancestorGenericDecl->parentDecl,
-                            specGenericSubst->getOuter(),
-                            substsToApply,
-                            &diff);
-
-                        auto firstSubst = specializeSubstitutionsShallow(
-                            astBuilder,
-                            specGenericSubst,
-                            substsToApply,
-                            restSubst,
-                            &diff);
-
-                        *ioDiff += diff;
-                        return firstSubst;
-                    }
-                }
-
-                // If the declaration is not already specialized
-                // for the given generic, then see if we are trying
-                // to *apply* such specializations to it.
-                //
-                // TODO: The way we handle things right now with
-                // "default" specializations, this case shouldn't
-                // actually come up.
-                //
-                for(auto s = substsToApply; s; s = s->getOuter())
-                {
-                    auto appGenericSubst = as<GenericSubstitution>(s);
-                    if(!appGenericSubst)
-                        continue;
-
-                    if(appGenericSubst->getGenericDecl() != ancestorGenericDecl)
-                        continue;
-
-                    // The substitutions we are applying are trying
-                    // to specialize this generic, but we don't already
-                    // have a generic substitution in place.
-                    // We will need to create one.
-
-                    int diff = 0;
-                    auto restSubst = specializeSubstitutions(
-                        astBuilder,
-                        ancestorGenericDecl->parentDecl,
-                        substsToSpecialize,
-                        substsToApply,
-                        &diff);
-
-                    GenericSubstitution* firstSubst = astBuilder->getOrCreateGenericSubstitution(
-                        restSubst, ancestorGenericDecl, appGenericSubst->getArgs());
-
-                    (*ioDiff)++;
-                    return firstSubst;
-                }
-            }
-            else if(auto ancestorInterfaceDecl = as<InterfaceDecl>(ancestorDecl))
-            {
-                // The task is basically the same as for the generic case:
-                // We want to see if there is any existing substitution that
-                // applies to this declaration, and use that if possible.
-
-                // The declaration is nested inside a generic.
-                // Does it already have a specialization for that generic?
-                if(auto specThisTypeSubst = as<ThisTypeSubstitution>(substsToSpecialize))
-                {
-                    if(specThisTypeSubst->interfaceDecl == ancestorInterfaceDecl)
-                    {
-                        // Yes. We have an existing specialization, so we will
-                        // keep one matching it in place.
-                        int diff = 0;
-                        auto restSubst = specializeSubstitutions(
-                            astBuilder,
-                            ancestorInterfaceDecl->parentDecl,
-                            specThisTypeSubst->getOuter(),
-                            substsToApply,
-                            &diff);
-
-                        auto firstSubst = specializeSubstitutionsShallow(
-                            astBuilder,
-                            specThisTypeSubst,
-                            substsToApply,
-                            restSubst,
-                            &diff);
-
-                        *ioDiff += diff;
-                        return firstSubst;
-                    }
-                }
-
-                // Otherwise, check if we are trying to apply
-                // a this-type substitution to the given interface
-                //
-                // Note: We want to skip the ThisTypeSubstitution that specializes
-                // declToSpecialize itself (when declToSpecialize is an interface
-                // decl and the subst specializes it), and only pull the
-                // ThisTypeSubstitution when the decl is referencing a child of
-                // the interface decl being specialized. This is because
-                // by default an interface declref type is a "free" existential
-                // type that shouldn't be specialized by someone else, unless
-                // there is an "implicit" ThisType reference preceeding a child
-                // reference.
-                if (declToSpecialize != ancestorInterfaceDecl)
-                {
-                    for (auto s = substsToApply; s; s = s->getOuter())
-                    {
-                        auto appThisTypeSubst = as<ThisTypeSubstitution>(s);
-                        if (!appThisTypeSubst)
-                            continue;
-
-                        if (appThisTypeSubst->interfaceDecl != ancestorInterfaceDecl)
-                            continue;
-
-                        int diff = 0;
-                        auto restSubst = specializeSubstitutions(
-                            astBuilder,
-                            ancestorInterfaceDecl->parentDecl,
-                            substsToSpecialize,
-                            substsToApply,
-                            &diff);
-
-                        ThisTypeSubstitution* firstSubst = astBuilder->getOrCreateThisTypeSubstitution(
-                            ancestorInterfaceDecl, appThisTypeSubst->witness, restSubst);
-
-                        (*ioDiff)++;
-                        return firstSubst;
-                    }
-                }
-            }
-        }
-
-        // If we reach here then we've walked the full hierarchy up from
-        // `declToSpecialize` and either didn't run into an generic/interface
-        // declarations, or we didn't find any attempt to specialize them
-        // in either substitution.
-        //
-        // As an invariant, there should *not* be any generic or this-type
-        // substitutions in `substToSpecialize`, because otherwise they
-        // would be specializations that don't actually apply to the given
-        // declaration.
-        //
-        // Note: this does *not* mean that `substsToApply` doesn't have
-        // any generic or this-type substitutions; it just means that none
-        // of them were applicable.
-        //
-        return nullptr;
-    }
-
-    DeclRefBase* DeclRefBase::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet substSet, int* ioDiff) const
-    {
-        // Nothing to do when we have no declaration.
-        if(!decl)
-            return const_cast<DeclRefBase*>(this);
-
-        // Apply the given substitutions to any specializations
-        // that have already been applied to this declaration.
-        int diff = 0;
-
-        auto substSubst = specializeSubstitutions(
-            astBuilder,
-            decl,
-            substitutions,
-            substSet.substitutions,
-            &diff);
-
-        if (!diff)
-            return const_cast<DeclRefBase*>(this);
-
-        *ioDiff += diff;
-
-        DeclRefBase* substDeclRef = astBuilder->getSpecializedDeclRef(decl, substSubst);
-
-        // TODO: The old code here used to try to translate a decl-ref
-        // to an associated type in a decl-ref for the concrete type
-        // in a particular implementation.
-        //
-        // I have only kept that logic in `DeclRefType::SubstituteImpl`,
-        // but it may turn out it is needed here too.
-
-        return substDeclRef;
-    }
-
-    bool DeclRefBase::_equalsValOverride(Val* val)
-    {
-        if (auto otherDeclRef = as<DeclRefBase>(val))
-            return equals(otherDeclRef);
-        return false;
-    }
-
-    // Check if this is an equivalent declaration reference to another
-    bool DeclRefBase::equals(DeclRefBase* declRef) const
-    {
-        if (!declRef)
-            return false;
-        if (decl != declRef->decl)
-            return false;
-        if (!SubstitutionSet(substitutions).equals(declRef->substitutions))
-            return false;
-
-        return true;
-    }
-
-    // Convenience accessors for common properties of declarations
-    Name* DeclRefBase::getName() const
-    {
-        return decl->nameAndLoc.name;
-    }
-    SourceLoc DeclRefBase::getNameLoc() const
-    {
-        return decl->nameAndLoc.loc;
-    }
-    SourceLoc DeclRefBase::getLoc() const
-    {
-        return decl->loc;
-    }
-
-    DeclRefBase* DeclRefBase::getParent(ASTBuilder* astBuilder) const
-    {
-        // Want access to the free function (the 'as' method by default gets priority)
-        // Can access as method with this->as because it removes any ambiguity.
-        using Slang::as;
-
-        auto parentDecl = decl->parentDecl;
-        if (!parentDecl)
-            return nullptr;
-
-        // Default is to apply the same set of substitutions/specializations
-        // to the parent declaration as were applied to the child.
-        Substitutions* substToApply = substitutions;
-
-        if(auto interfaceDecl = as<InterfaceDecl>(decl))
-        {
-            // The declaration being referenced is an `interface` declaration,
-            // and there might be a this-type substitution in place.
-            // A reference to the parent of the interface declaration
-            // should not include that substitution.
-            if(auto thisTypeSubst = as<ThisTypeSubstitution>(substToApply))
-            {
-                if(thisTypeSubst->interfaceDecl == interfaceDecl)
-                {
-                    // Strip away that specializations that apply to the interface.
-                    substToApply = thisTypeSubst->getOuter();
-                }
-            }
-        }
-
-        if (auto parentGenericDecl = as<GenericDecl>(parentDecl))
-        {
-            // The parent of this declaration is a generic, which means
-            // that the decl-ref to the current declaration might include
-            // substitutions that specialize the generic parameters.
-            // A decl-ref to the parent generic should *not* include
-            // those substitutions.
-            //
-            if(auto genericSubst = as<GenericSubstitution>(substToApply))
-            {
-                if(genericSubst->getGenericDecl() == parentGenericDecl)
-                {
-                    // Strip away the specializations that were applied to the parent.
-                    substToApply = genericSubst->getOuter();
-                }
-            }
-        }
-
-        return astBuilder->getSpecializedDeclRef(parentDecl, substToApply);
-    }
-
-    HashCode DeclRefBase::getHashCode() const
-    {
-        return combineHash(PointerHash<1>::getHashCode(decl), SubstitutionSet(substitutions).getHashCode());
-    }
-
     // IntVal
 
     IntegerLiteralValue getIntVal(IntVal* val)
     {
         if (auto constantVal = as<ConstantIntVal>(val))
         {
-            return constantVal->value;
+            return constantVal->getValue();
         }
         SLANG_UNEXPECTED("needed a known integer value");
         //return 0;
@@ -1125,14 +534,22 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
 
     // HLSLPatchType
 
+    Val* getGenericArg(DeclRef<Decl> declRef, Index index)
+    {
+        auto subst = SubstitutionSet(declRef).findGenericAppDeclRef();
+        if (index < subst->getArgs().getCount())
+            return subst->getArgs()[index];
+        return nullptr;
+    }
+
     Type* HLSLPatchType::getElementType()
     {
-        return as<Type>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[0]);
+        return as<Type>(getGenericArg(getDeclRef(), 0));
     }
 
     IntVal* HLSLPatchType::getElementCount()
     {
-        return as<IntVal>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[1]);
+        return as<IntVal>(getGenericArg(getDeclRef(), 1));
     }
 
     // MeshOutputType
@@ -1143,12 +560,12 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
 
     Type* MeshOutputType::getElementType()
     {
-        return as<Type>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[0]);
+        return as<Type>(getGenericArg(getDeclRef(), 0));
     }
 
     IntVal* MeshOutputType::getMaxElementCount()
     {
-        return as<IntVal>(findInnerMostGenericSubstitution(declRef.getSubst())->getArgs()[1]);
+        return as<IntVal>(getGenericArg(getDeclRef(), 1));
     }
 
     // Constructors for types
@@ -1174,17 +591,16 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
     {
         DeclRef<TypeDefDecl> specializedDeclRef = createDefaultSubstitutionsIfNeeded(astBuilder, nullptr, declRef).as<TypeDefDecl>();
 
-        return astBuilder->create<NamedExpressionType>(specializedDeclRef);
+        return astBuilder->getOrCreate<NamedExpressionType>(specializedDeclRef);
     }
     
     FuncType* getFuncType(
         ASTBuilder*                     astBuilder,
         DeclRef<CallableDecl> const&    declRef)
     {
-        FuncType* funcType = astBuilder->create<FuncType>();
-
-        funcType->resultType = getResultType(astBuilder, declRef);
-        funcType->errorType = getErrorCodeType(astBuilder, declRef);
+        List<Type*> paramTypes;
+        auto resultType = getResultType(astBuilder, declRef);
+        auto errorType = getErrorCodeType(astBuilder, declRef);
         for (auto paramDeclRef : getParameters(astBuilder, declRef))
         {
             auto paramDecl = paramDeclRef.getDecl();
@@ -1204,9 +620,10 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
                     paramType = astBuilder->getOutType(paramType);
                 }
             }
-            funcType->paramTypes.add(paramType);
+            paramTypes.add(paramType);
         }
 
+        FuncType* funcType = astBuilder->getOrCreate<FuncType>(paramTypes.getArrayView(), resultType, errorType);
         return funcType;
     }
 
@@ -1214,40 +631,34 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
         ASTBuilder*                 astBuilder,
         DeclRef<GenericDecl> const& declRef)
     {
-        return astBuilder->create<GenericDeclRefType>(declRef);
+        return astBuilder->getOrCreate<GenericDeclRefType>(declRef);
     }
 
     NamespaceType* getNamespaceType(
         ASTBuilder*                         astBuilder,
         DeclRef<NamespaceDeclBase> const&   declRef)
     {
-        auto type = astBuilder->create<NamespaceType>();
-        type->declRef = declRef;
+        auto type = astBuilder->getOrCreate<NamespaceType>(declRef);
         return type;
     }
 
     SamplerStateType* getSamplerStateType(
         ASTBuilder*     astBuilder)
     {
-        return astBuilder->create<SamplerStateType>();
+        return astBuilder->getSamplerStateType();
     }
 
-    ThisTypeSubstitution* findThisTypeSubstitution(
-        const Substitutions*  substs,
+    SubtypeWitness* findThisTypeWitness(
+        SubstitutionSet  substs,
         InterfaceDecl*  interfaceDecl)
     {
-        for(const Substitutions* s = substs; s; s = s->getOuter())
+        auto lookupDeclRef = substs.findLookupDeclRef();
+        if (!lookupDeclRef)
+            return nullptr;
+        if (lookupDeclRef->getSupDecl() == interfaceDecl)
         {
-            auto thisTypeSubst = as<ThisTypeSubstitution>(s);
-            if(!thisTypeSubst)
-                continue;
-
-            if(thisTypeSubst->interfaceDecl != interfaceDecl)
-                continue;
-
-            return const_cast<ThisTypeSubstitution*>(thisTypeSubst);
+            return lookupDeclRef->getWitness();
         }
-
         return nullptr;
     }
 
@@ -1259,20 +670,16 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
 
         auto substAssocTypeDecl = substDeclRef.getDecl();
 
-        for (auto s = substDeclRef.getSubst(); s; s = s->getOuter())
+        if (auto lookupDeclRef = SubstitutionSet(substDeclRef).findLookupDeclRef())
         {
-            auto thisSubst = as<ThisTypeSubstitution>(s);
-            if (!thisSubst)
-                continue;
-
             if (auto interfaceDecl = as<InterfaceDecl>(substAssocTypeDecl->parentDecl))
             {
-                if (thisSubst->interfaceDecl == interfaceDecl)
+                if (lookupDeclRef->getSupDecl() == interfaceDecl)
                 {
                     // We need to look up the declaration that satisfies
                     // the requirement named by the associated type.
                     Decl* requirementKey = substAssocTypeDecl;
-                    RequirementWitness requirementWitness = tryLookUpRequirementWitness(builder, thisSubst->witness, requirementKey);
+                    RequirementWitness requirementWitness = tryLookUpRequirementWitness(builder, lookupDeclRef->getWitness(), requirementKey);
                     switch (requirementWitness.getFlavor())
                     {
                     default:
@@ -1296,17 +703,17 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
                         if (builtinReq->kind != BuiltinRequirementKind::DifferentialType)
                             return nullptr;
                         // Is the concrete type a Differential associated type?
-                        auto innerDeclRefType = as<DeclRefType>(thisSubst->witness->sub);
+                        auto innerDeclRefType = as<DeclRefType>(lookupDeclRef->getWitness()->getSub());
                         if (!innerDeclRefType)
                             return nullptr;
-                        auto innerBuiltinReq = innerDeclRefType->declRef.getDecl()->findModifier<BuiltinRequirementModifier>();
+                        auto innerBuiltinReq = innerDeclRefType->getDeclRef().getDecl()->findModifier<BuiltinRequirementModifier>();
                         if (!innerBuiltinReq)
                             return nullptr;
                         if (innerBuiltinReq->kind != BuiltinRequirementKind::DifferentialType)
                             return nullptr;
-                        if (!innerDeclRefType->declRef.equals(declRef))
+                        if (!innerDeclRefType->getDeclRef().equals(declRef))
                         {
-                            auto result = _tryLookupConcreteAssociatedTypeFromThisTypeSubst(builder, innerDeclRefType->declRef);
+                            auto result = _tryLookupConcreteAssociatedTypeFromThisTypeSubst(builder, innerDeclRefType->getDeclRef());
                             if (result)
                                 return result;
                         }
@@ -1320,119 +727,6 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
         return nullptr;
     }
 
-    String DeclRefBase::toString() const
-    {
-        StringBuilder builder;
-        toText(builder);
-        return std::move(builder);
-    }
-
-    // Prints a partially qualified type name with generic substitutions.
-    void _printNestedDecl(const Substitutions* substitutions, const Decl* decl, StringBuilder& out)
-    {
-        // If there is a parent scope for the declaration, print it first.
-        // Exclude top-level namespaces like `tu0` or `core`.
-        if (decl->parentDecl && !Slang::as<ModuleDecl>(decl->parentDecl))
-        {
-            auto parentGeneric = Slang::as<GenericDecl>(decl->parentDecl);
-
-            // Exclude function or operator names.
-            // Avoids excessively verbose messages like `func<T>(func::T)`
-            if (!(parentGeneric && Slang::as<CallableDecl>(parentGeneric->inner)))
-            {
-                _printNestedDecl(substitutions, decl->parentDecl, out);
-
-                // If the parent is a generic for this type, skip *this* type.
-                // Avoids duplicate types like `MyType<T>::MyType`
-                if (parentGeneric && parentGeneric->inner == decl)
-                    return;
-
-                out << ".";
-            }
-        }
-        // If we have a ThisTypeSubstitution to an interface decl, print the substituted sub
-        // type instead.
-        for (;;)
-        {
-            if (auto interfaceDecl = const_cast<InterfaceDecl*>(as<InterfaceDecl>(decl)))
-            {
-                if (auto thisSubst = findThisTypeSubstitution(substitutions, interfaceDecl))
-                {
-                    if (auto subTypeWitness = as<SubtypeWitness>(thisSubst->witness))
-                    {
-                        out << subTypeWitness->sub;
-                        break;
-                    }
-                }
-            }
-            // Otherwise, just print this type's name.
-            auto name = decl->getName();
-            if (name)
-            {
-                out << name->text;
-            }
-            break;
-        }
-
-        // Look for generic substitutions on this type.
-        for (const Substitutions* subst = substitutions; subst; subst = subst->getOuter())
-        {
-            auto genericSubstitution = Slang::as<GenericSubstitution>(subst);
-            if (!genericSubstitution)
-                continue;
-
-            // If the substitution is for this type, print it.
-            if (genericSubstitution->getGenericDecl() == decl)
-            {
-                out << "<";
-                bool isFirst = true;
-                for (const auto& it : genericSubstitution->getArgs())
-                {
-                    // Don't print out witnesses.
-                    if (as<Witness>(it))
-                        continue;
-                    if (!isFirst)
-                        out << ", ";
-                    isFirst = false;
-                    it->toText(out);
-                }
-                out << ">";
-
-                break;
-            }
-        }
-    }
-
-    void DeclRefBase::toText(StringBuilder& out) const
-    {
-        if (decl)
-        {
-            _printNestedDecl(substitutions, decl, out);
-        }
-    }
-
-    bool SubstitutionSet::equals(const SubstitutionSet& substSet) const
-    {
-        if (substitutions == substSet.substitutions)
-        {
-            return true;
-        }
-        if (substitutions == nullptr || substSet.substitutions == nullptr)
-        {
-            return false;
-        }
-        return substitutions->equals(substSet.substitutions);
-    }
-
-    HashCode SubstitutionSet::getHashCode() const
-    {
-        HashCode rs = 0;
-        if (substitutions)
-            rs = combineHash(rs, substitutions->getHashCode());
-        return rs;
-    }
-
-
 ModuleDecl* getModuleDecl(Decl* decl)
 {
     for( auto dd = decl; dd; dd = dd->parentDecl )
diff --git a/source/slang/slang-syntax.h b/source/slang/slang-syntax.h
index a63a2471c..4addb1d53 100644
--- a/source/slang/slang-syntax.h
+++ b/source/slang/slang-syntax.h
@@ -22,22 +22,22 @@ namespace Slang
     inline bool areValsEqual(Val* left, Val* right)
     {
         if(!left || !right) return left == right;
-        return left->equalsVal(right);
+        return left->equals(right);
     }
 
     //
 
     inline BaseType getVectorBaseType(VectorExpressionType* vecType)
     {
-        auto basicExprType = as<BasicExpressionType>(vecType->elementType);
-        return basicExprType->baseType;
+        auto basicExprType = as<BasicExpressionType>(vecType->getElementType());
+        return basicExprType->getBaseType();
     }
 
     inline int getVectorSize(VectorExpressionType* vecType)
     {
-        auto constantVal = as<ConstantIntVal>(vecType->elementCount);
+        auto constantVal = as<ConstantIntVal>(vecType->getElementCount());
         if (constantVal)
-            return (int) constantVal->value;
+            return (int) constantVal->getValue();
         // TODO: what to do in this case?
         return 0;
     }
@@ -52,15 +52,21 @@ namespace Slang
         DeclRef<AggTypeDecl> const& declRef,
         SemanticsVisitor*           semantics);
 
+    // Returns the members of `genericInnerDecl`'s enclosing generic decl.
+    inline FilteredMemberRefList<Decl> getGenericMembers(ASTBuilder* astBuilder, DeclRef<Decl> genericInnerDecl, MemberFilterStyle filterStyle = MemberFilterStyle::All)
+    {
+        return FilteredMemberRefList<Decl>(astBuilder, genericInnerDecl.getParent().getDecl()->members, genericInnerDecl, filterStyle);
+    }
+
     inline FilteredMemberRefList<Decl> getMembers(ASTBuilder* astBuilder, DeclRef<ContainerDecl> declRef, MemberFilterStyle filterStyle = MemberFilterStyle::All)
     {
-        return FilteredMemberRefList<Decl>(astBuilder, declRef.getDecl()->members, declRef.getSubst(), filterStyle);
+        return FilteredMemberRefList<Decl>(astBuilder, declRef.getDecl()->members, declRef, filterStyle);
     }
 
     template<typename T>
     inline FilteredMemberRefList<T> getMembersOfType(ASTBuilder* astBuilder, DeclRef<ContainerDecl> declRef, MemberFilterStyle filterStyle = MemberFilterStyle::All)
     {
-        return FilteredMemberRefList<T>(astBuilder, declRef.getDecl()->members, declRef.getSubst(), filterStyle);
+        return FilteredMemberRefList<T>(astBuilder, declRef.getDecl()->members, declRef, filterStyle);
     }
 
     void _foreachDirectOrExtensionMemberOfType(
@@ -70,7 +76,7 @@ namespace Slang
         void                            (*callback)(DeclRefBase*, void*),
         void const*                     userData);
 
-    DeclRef<Decl> _getSpecializedDeclRef(ASTBuilder* builder, Decl* decl, Substitutions* subst);
+    DeclRef<Decl> _getMemberDeclRef(ASTBuilder* builder, DeclRef<Decl> parent, Decl* decl);
 
     template<typename T, typename F>
     inline void foreachDirectOrExtensionMemberOfType(
@@ -153,6 +159,26 @@ namespace Slang
         /// If the given `structTypeDeclRef` inherits from another struct type, return that base struct decl
     DeclRef<StructDecl> findBaseStructDeclRef(ASTBuilder* astBuilder, DeclRef<StructDecl> structTypeDeclRef);
 
+    SubtypeWitness* findThisTypeWitness(
+        SubstitutionSet substs,
+        InterfaceDecl* interfaceDecl);
+
+    RequirementWitness tryLookUpRequirementWitness(
+        ASTBuilder* astBuilder,
+        SubtypeWitness* subtypeWitness,
+        Decl* requirementKey);
+
+    DeclRef<Decl> createDefaultSubstitutionsIfNeeded(
+        ASTBuilder* astBuilder,
+        SemanticsVisitor* semantics,
+        DeclRef<Decl>   declRef);
+
+    List<Val*> getDefaultSubstitutionArgs(ASTBuilder* astBuilder, SemanticsVisitor* semantics, GenericDecl* genericDecl);
+
+    Val::OperandView<Val> findInnerMostGenericArgs(SubstitutionSet subst);
+
+    ParameterDirection getParameterDirection(VarDeclBase* varDecl);
+
     inline Type* getTagType(ASTBuilder* astBuilder, DeclRef<EnumDecl> declRef)
     {
         return declRef.substitute(astBuilder, declRef.getDecl()->tagType);
@@ -192,8 +218,6 @@ namespace Slang
 
     inline Decl* getInner(DeclRef<GenericDecl> declRef)
     {
-        // TODO: Should really return a `DeclRef<Decl>` for the inner
-        // declaration, and not just a raw pointer
         return declRef.getDecl()->inner;
     }
 
@@ -288,46 +312,6 @@ namespace Slang
 
     //
 
-    ThisTypeSubstitution* findThisTypeSubstitution(
-        const Substitutions*  substs,
-        InterfaceDecl*  interfaceDecl);
-
-    RequirementWitness tryLookUpRequirementWitness(
-        ASTBuilder*     astBuilder,
-        SubtypeWitness* subtypeWitness,
-        Decl*           requirementKey);
-
-    // TODO: where should this live?
-    SubstitutionSet createDefaultSubstitutions(
-        ASTBuilder*     astBuilder,
-        SemanticsVisitor* semantics,
-        Decl*           decl,
-        SubstitutionSet  parentSubst);
-
-    SubstitutionSet createDefaultSubstitutions(
-        ASTBuilder*     astBuilder,
-        SemanticsVisitor* semantics,
-        Decl*   decl);
-
-    DeclRef<Decl> createDefaultSubstitutionsIfNeeded(
-        ASTBuilder*     astBuilder,
-        SemanticsVisitor* semantics,
-        DeclRef<Decl>   declRef);
-
-    GenericSubstitution* createDefaultSubstitutionsForGeneric(
-        ASTBuilder*             astBuilder,
-        SemanticsVisitor* semantics,
-        GenericDecl*            genericDecl,
-        Substitutions*   outerSubst);
-
-    GenericSubstitution* findInnerMostGenericSubstitution(Substitutions* subst);
-
-    ThisTypeSubstitution* findThisTypeSubstitution(
-        const Substitutions* substs,
-        InterfaceDecl* interfaceDecl);
-
-    ParameterDirection getParameterDirection(VarDeclBase* varDecl);
-
     enum class UserDefinedAttributeTargets
     {
         None = 0,
diff --git a/source/slang/slang-type-layout.cpp b/source/slang/slang-type-layout.cpp
index 5cf8d2350..f5e14366d 100644
--- a/source/slang/slang-type-layout.cpp
+++ b/source/slang/slang-type-layout.cpp
@@ -1571,9 +1571,9 @@ static LayoutSize GetElementCount(IntVal* val)
 
     if (auto constantVal = as<ConstantIntVal>(val))
     {
-        if (constantVal->value == kUnsizedArrayMagicLength)
+        if (constantVal->getValue() == kUnsizedArrayMagicLength)
             return LayoutSize::infinite();
-        return LayoutSize(LayoutSize::RawValue(constantVal->value));
+        return LayoutSize(LayoutSize::RawValue(constantVal->getValue()));
     }
     else if(const auto varRefVal = as<GenericParamIntVal>(val))
     {
@@ -2766,7 +2766,7 @@ RefPtr<TypeLayout> createParameterGroupTypeLayout(
         parameterGroupRules,
         context.targetReq);
 
-    auto elementType = parameterGroupType->elementType;
+    auto elementType = parameterGroupType->getElementType();
 
     return _createParameterGroupTypeLayout(
         context,
@@ -3642,24 +3642,6 @@ static void _addLayout(TypeLayoutContext const& context,
 
 static TypeLayoutResult _updateLayout(TypeLayoutContext const& context,
     Type* type,
-    TypeLayout* layout,
-    const SimpleLayoutInfo& info)
-{
-    auto layoutResultPtr = context.layoutMap.tryGetValue(type);
-    SLANG_ASSERT(layoutResultPtr);
-    if (layoutResultPtr)
-    {
-        // Check the layout is the same!
-        SLANG_ASSERT(layoutResultPtr->layout.get() == layout);
-        // Update the info
-        layoutResultPtr->info = info;
-    }
-
-    return TypeLayoutResult(layout, info);
-}
-
-static TypeLayoutResult _updateLayout(TypeLayoutContext const& context,
-    Type* type,
     const TypeLayoutResult& result)
 {
     auto layoutResultPtr = context.layoutMap.tryGetValue(type);
@@ -3791,7 +3773,7 @@ static TypeLayoutResult _createTypeLayout(
                 context,                                                \
                 ShaderParameterKind::KIND,                              \
                 type_##TYPE,                                            \
-                type_##TYPE->elementType);                        \
+                type_##TYPE->getElementType());                         \
         return TypeLayoutResult(typeLayout, info);                      \
     } while(0)
 
@@ -3826,14 +3808,14 @@ static TypeLayoutResult _createTypeLayout(
     else if(auto basicType = as<BasicExpressionType>(type))
     {
         return createSimpleTypeLayout(
-            rules->GetScalarLayout(basicType->baseType),
+            rules->GetScalarLayout(basicType->getBaseType()),
             type,
             rules);
     }
     else if(auto vecType = as<VectorExpressionType>(type))
     {
-        auto elementType = vecType->elementType;
-        size_t elementCount = (size_t) getIntVal(vecType->elementCount);
+        auto elementType = vecType->getElementType();
+        size_t elementCount = (size_t) getIntVal(vecType->getElementCount());
 
         auto element = _createTypeLayout(
             context,
@@ -3842,7 +3824,7 @@ static TypeLayoutResult _createTypeLayout(
         BaseType elementBaseType = BaseType::Void;
         if (auto elementBasicType = as<BasicExpressionType>(elementType))
         {
-            elementBaseType = elementBasicType->baseType;
+            elementBaseType = elementBasicType->getBaseType();
         }
 
         auto info = rules->GetVectorLayout(elementBaseType, element.info, elementCount);
@@ -3874,7 +3856,7 @@ static TypeLayoutResult _createTypeLayout(
         BaseType elementBaseType = BaseType::Void;
         if (auto elementBasicType = as<BasicExpressionType>(elementType))
         {
-            elementBaseType = elementBasicType->baseType;
+            elementBaseType = elementBasicType->getBaseType();
         }
 
         // The `GetMatrixLayout` implementation in the layout rules
@@ -3972,7 +3954,7 @@ static TypeLayoutResult _createTypeLayout(
     }
     else if (auto declRefType = as<DeclRefType>(type))
     {
-        auto declRef = declRefType->declRef;
+        auto declRef = declRefType->getDeclRef();
 
         if (auto structDeclRef = declRef.as<StructDecl>())
         {
@@ -4346,99 +4328,20 @@ static TypeLayoutResult _createTypeLayout(
             errorType,
             rules);
     }
-    else if( auto taggedUnionType = as<TaggedUnionType>(type) )
+    else if( auto existentialSpecializedType = as<ExistentialSpecializedType>(type) )
     {
-        // A tagged union type needs to be laid out as the maximum
-        // size of any constituent type.
-        //
-        // In practice, only a tagged union of uniform data will
-        // work, but for now we will compute the maximum usage
-        // for each resource kind for generality.
-        //
-        // For the uniform data we will start with a size
-        // of zero and an alignment of one for our base case
-        // (this is what a tagged union of no cases would consume).
-        //
-        UniformLayoutInfo info(0, 1);
-
-        RefPtr<TaggedUnionTypeLayout> taggedUnionLayout = new TaggedUnionTypeLayout();
-
-        _addLayout(context, type, taggedUnionLayout);
-
-        taggedUnionLayout->type = type;
-        taggedUnionLayout->rules = rules;
-
-        // Now we iterate over the case types and see if they
-        // change our computed maximum size/alignement.
-        //
-        for( auto caseType : taggedUnionType->caseTypes )
+        ExpandedSpecializationArgs args;
+        for (Index i = 0; i < existentialSpecializedType->getArgCount(); ++i)
         {
-            // Note: A tagged union type is not expected to have any existential/interface type
-            // slots; the case types that are provided must be fully specialized before the union is
-            // formed. Thus we don't need to mess around with existential type slots here the
-            // way we do for the `struct` case.
-
-            auto caseTypeResult = _createTypeLayout(context, caseType);
-            RefPtr<TypeLayout> caseTypeLayout = caseTypeResult.layout;
-            UniformLayoutInfo caseTypeInfo = caseTypeResult.info.getUniformLayout();
-
-            info.size      = maximum(info.size, caseTypeInfo.size);
-            info.alignment = std::max(info.alignment, caseTypeInfo.alignment);
-
-            // We need to remember the layout of the case type
-            // on the final `TaggedUnionTypeLayout`.
-            //
-            taggedUnionLayout->caseTypeLayouts.add(caseTypeLayout);
-
-            // We also need to consider contributions for other
-            // resource kinds beyond uniform data.
-            //
-            for( auto caseResInfo : caseTypeLayout->resourceInfos )
-            {
-                auto unionResInfo = taggedUnionLayout->findOrAddResourceInfo(caseResInfo.kind);
-                unionResInfo->count = maximum(unionResInfo->count, caseResInfo.count);
-            }
-        }
-
-        // After we've computed the size required to hold all the
-        // case types, we will allocate space for the tag field.
-        //
-        // TODO: This assumes the tag will always be allocated out
-        // of uniform storage, which means we can't support a tagged
-        // union as part of a varying input/output signature. That is
-        // probably a valid limitation, but it should get enforced
-        // somewhere along the way.
-        //
-        {
-            // The tag is always a `uint` for now.
-            //
-            auto tagInfo = context.rules->GetScalarLayout(BaseType::UInt);
-            info.size = _roundToAlignment(info.size, tagInfo.alignment);
-
-            taggedUnionLayout->tagOffset = info.size;
-
-            info.size += tagInfo.size;
-            info.alignment = std::max(info.alignment, tagInfo.alignment);
+            args.add(existentialSpecializedType->getArg(i));
         }
-
-        // As a final step, if we are computing a full `TypeLayout`
-        // we will make sure that its information on uniform layout
-        // matches what we've computed in the `UniformLayoutInfo` we return.
-        //
-        taggedUnionLayout->findOrAddResourceInfo(LayoutResourceKind::Uniform)->count = info.size;
-        taggedUnionLayout->uniformAlignment = info.alignment;
-
-        return _updateLayout(context, type, taggedUnionLayout, info);
-    }
-    else if( auto existentialSpecializedType = as<ExistentialSpecializedType>(type) )
-    {
         TypeLayoutContext subContext = context.withSpecializationArgs(
-            existentialSpecializedType->args.getBuffer(),
-            existentialSpecializedType->args.getCount());
+            args.getBuffer(),
+            args.getCount());
 
         auto baseTypeLayoutResult = _createTypeLayout(
             subContext,
-            existentialSpecializedType->baseType);
+            existentialSpecializedType->getBaseType());
 
         UniformLayoutInfo info = rules->BeginStructLayout();
         rules->AddStructField(&info, baseTypeLayoutResult.info.getUniformLayout());
@@ -4534,7 +4437,7 @@ RefPtr<TypeLayout> getSimpleVaryingParameterTypeLayout(
 
     if(auto basicType = as<BasicExpressionType>(type))
     {
-        auto baseType = basicType->baseType;
+        auto baseType = basicType->getBaseType();
 
         RefPtr<TypeLayout> typeLayout = new TypeLayout();
         typeLayout->type = type;
@@ -4550,13 +4453,13 @@ RefPtr<TypeLayout> getSimpleVaryingParameterTypeLayout(
     }
     else if(auto vecType = as<VectorExpressionType>(type))
     {
-        auto elementType = vecType->elementType;
-        size_t elementCount = (size_t) getIntVal(vecType->elementCount);
+        auto elementType = vecType->getElementType();
+        size_t elementCount = (size_t) getIntVal(vecType->getElementCount());
 
         BaseType elementBaseType = BaseType::Void;
         if( auto elementBasicType = as<BasicExpressionType>(elementType) )
         {
-            elementBaseType = elementBasicType->baseType;
+            elementBaseType = elementBasicType->getBaseType();
         }
 
         // Note that we do *not* add any resource usage to the type
@@ -4592,7 +4495,7 @@ RefPtr<TypeLayout> getSimpleVaryingParameterTypeLayout(
         BaseType elementBaseType = BaseType::Void;
         if( auto elementBasicType = as<BasicExpressionType>(elementType) )
         {
-            elementBaseType = elementBasicType->baseType;
+            elementBaseType = elementBasicType->getBaseType();
         }
 
         // Just as for `_createTypeLayout`, we need to handle row- and
@@ -4711,7 +4614,7 @@ GlobalGenericParamDecl* GenericParamTypeLayout::getGlobalGenericParamDecl()
 {
     auto declRefType = as<DeclRefType>(type);
     SLANG_ASSERT(declRefType);
-    auto rsDeclRef = declRefType->declRef.as<GlobalGenericParamDecl>();
+    auto rsDeclRef = declRefType->getDeclRef().as<GlobalGenericParamDecl>();
     return rsDeclRef.getDecl();
 }
 
diff --git a/source/slang/slang-type-layout.h b/source/slang/slang-type-layout.h
index 7b822eac4..c800d0931 100644
--- a/source/slang/slang-type-layout.h
+++ b/source/slang/slang-type-layout.h
@@ -725,28 +725,6 @@ public:
     Index paramIndex = 0;
 };
 
-    /// Layout information for a tagged union type.
-class TaggedUnionTypeLayout : public TypeLayout
-{
-public:
-        /// The layouts of each of the case types.
-        ///
-        /// The order of entries in this array matches
-        /// the order of case types on the original
-        /// `TaggedUnionType`, and the index of a case
-        /// type is also the tag value for that case.
-        ///
-    List<RefPtr<TypeLayout>> caseTypeLayouts;
-
-        /// The byte offset for the tag field.
-        ///
-        /// The tag field will always be allocated as
-        /// a `uint`, so we don't store a separate layout
-        /// for it.
-        ///
-    LayoutSize tagOffset;
-};
-
     /// Layout information for an interface/existential type
     ///
     /// This class is used to represent the layout of an interface type
@@ -912,13 +890,6 @@ public:
         ///
     Dictionary<GlobalGenericParamDecl*, Val*> globalGenericArgs;
 
-        /// Layouts for all tagged union types required by this program
-        ///
-        /// These are any tagged union types used by the specialization
-        /// arguments that have been used to specialize the program.
-        ///
-    List<RefPtr<TypeLayout>> taggedUnionTypeLayouts;
-
         /// Holds all of the string literals that have been hashed
     StringSlicePool hashedStringLiteralPool;
 };
diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp
index e08bb2a62..266533874 100644
--- a/source/slang/slang.cpp
+++ b/source/slang/slang.cpp
@@ -161,11 +161,9 @@ void Session::init()
     m_sharedASTBuilder = new SharedASTBuilder;
     m_sharedASTBuilder->init(this);
 
-    //  Use to create a ASTBuilder
-    RefPtr<ASTBuilder> builtinAstBuilder(new ASTBuilder(m_sharedASTBuilder, "m_builtInLinkage::m_astBuilder"));
-
     // And the global ASTBuilder
-    globalAstBuilder = new ASTBuilder(m_sharedASTBuilder, "globalAstBuilder");
+    auto builtinAstBuilder = m_sharedASTBuilder->getInnerASTBuilder();
+    globalAstBuilder = builtinAstBuilder;
 
     // Make sure our source manager is initialized
     builtinSourceManager.initialize(nullptr, nullptr);
@@ -367,6 +365,8 @@ SlangResult Session::loadStdLib(const void* stdLib, size_t stdLibSizeInBytes)
         return SLANG_FAIL;
     }
 
+    SLANG_AST_BUILDER_RAII(m_builtinLinkage->getASTBuilder());
+
     // Make a file system to read it from
     ComPtr<ISlangFileSystemExt> fileSystem;
     SLANG_RETURN_ON_FAIL(loadArchiveFileSystem(stdLib, stdLibSizeInBytes, fileSystem));
@@ -397,6 +397,8 @@ SlangResult Session::saveStdLib(SlangArchiveType archiveType, ISlangBlob** outBl
         return SLANG_FAIL;
     }
 
+    SLANG_AST_BUILDER_RAII(m_builtinLinkage->getASTBuilder());
+
     for (auto& pair : m_builtinLinkage->mapNameToLoadedModules)
     {
         const Name* moduleName = pair.key;
@@ -463,6 +465,7 @@ SlangResult Session::_readBuiltinModule(ISlangFileSystem* fileSystem, Scope* sco
     options.namePool = linkageNamePool;
     options.session = this;
     options.sharedASTBuilder = linkage->getASTBuilder()->getSharedASTBuilder();
+    options.astBuilder = linkage->getASTBuilder();
     options.sourceManager = sourceManger;
     options.linkage = linkage;
 
@@ -920,6 +923,9 @@ Linkage::Linkage(Session* session, ASTBuilder* astBuilder, Linkage* builtinLinka
     , m_sourceManager(&m_defaultSourceManager)
     , m_astBuilder(astBuilder)
 {
+    if (builtinLinkage)
+        m_astBuilder->m_cachedNodes = builtinLinkage->getASTBuilder()->m_cachedNodes;
+
     getNamePool()->setRootNamePool(session->getRootNamePool());
 
     m_defaultSourceManager.initialize(session->getBuiltinSourceManager(), nullptr);
@@ -990,6 +996,8 @@ SLANG_NO_THROW slang::IGlobalSession* SLANG_MCALL Linkage::getGlobalSession()
 void Linkage::addTarget(
     slang::TargetDesc const&  desc)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     auto targetIndex = addTarget(CodeGenTarget(desc.format));
     auto target = targets[targetIndex];
 
@@ -1018,6 +1026,8 @@ SLANG_NO_THROW slang::IModule* SLANG_MCALL Linkage::loadModule(
     const char*     moduleName,
     slang::IBlob**  outDiagnostics)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     DiagnosticSink sink(getSourceManager(), Lexer::sourceLocationLexer);
 
     if (isInLanguageServer())
@@ -1048,6 +1058,8 @@ SLANG_NO_THROW slang::IModule* SLANG_MCALL Linkage::loadModuleFromSource(
     slang::IBlob* source,
     slang::IBlob** outDiagnostics)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     DiagnosticSink sink(getSourceManager(), Lexer::sourceLocationLexer);
     if (isInLanguageServer())
     {
@@ -1096,6 +1108,8 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::createCompositeComponentType(
     slang::IComponentType**         outCompositeComponentType,
     ISlangBlob**                    outDiagnostics)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     // Attempting to create a "composite" of just one component type should
     // just return the component type itself, to avoid redundant work.
     //
@@ -1131,6 +1145,8 @@ SLANG_NO_THROW slang::TypeReflection* SLANG_MCALL Linkage::specializeType(
     SlangInt                        specializationArgCount,
     ISlangBlob**                    outDiagnostics)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     auto unspecializedType = asInternal(inUnspecializedType);
 
     List<Type*> typeArgs;
@@ -1157,6 +1173,8 @@ SLANG_NO_THROW slang::TypeLayoutReflection* SLANG_MCALL Linkage::getTypeLayout(
     slang::LayoutRules      rules,
     ISlangBlob**            outDiagnostics)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     auto type = asInternal(inType);
 
     if(targetIndex < 0 || targetIndex >= targets.getCount())
@@ -1187,6 +1205,8 @@ SLANG_NO_THROW slang::TypeReflection* SLANG_MCALL Linkage::getContainerType(
     slang::ContainerType containerType,
     ISlangBlob** outDiagnostics)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     auto type = asInternal(inType);
 
     Type* containerTypeReflection = nullptr;
@@ -1197,29 +1217,20 @@ SLANG_NO_THROW slang::TypeReflection* SLANG_MCALL Linkage::getContainerType(
         {
         case slang::ContainerType::ConstantBuffer:
             {
-                ConstantBufferType* cbType = getASTBuilder()->create<ConstantBufferType>();
-                cbType->elementType = type;
-                cbType->declRef = getASTBuilder()->getBuiltinDeclRef(
-                    "ConstantBuffer", static_cast<Val*>(type));
+                ConstantBufferType* cbType = getASTBuilder()->getConstantBufferType(type);
                 containerTypeReflection = cbType;
             }
             break;
         case slang::ContainerType::ParameterBlock:
             {
-                ParameterBlockType* pbType = getASTBuilder()->create<ParameterBlockType>();
-                pbType->elementType = type;
-                pbType->declRef = getASTBuilder()->getBuiltinDeclRef(
-                    "ParameterBlock", static_cast<Val*>(type));
+                ParameterBlockType* pbType = getASTBuilder()->getParameterBlockType(type);
                 containerTypeReflection = pbType;
             }
             break;
         case slang::ContainerType::StructuredBuffer:
             {
                 HLSLStructuredBufferType* sbType =
-                    getASTBuilder()->create<HLSLStructuredBufferType>();
-                sbType->elementType = type;
-                sbType->declRef = getASTBuilder()->getBuiltinDeclRef(
-                    "HLSLStructuredBufferType", static_cast<Val*>(type));
+                    getASTBuilder()->getStructuredBufferType(type);
                 containerTypeReflection = sbType;
             }
             break;
@@ -1244,16 +1255,20 @@ SLANG_NO_THROW slang::TypeReflection* SLANG_MCALL Linkage::getContainerType(
 
 SLANG_NO_THROW slang::TypeReflection* SLANG_MCALL Linkage::getDynamicType()
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     return asExternal(getASTBuilder()->getSharedASTBuilder()->getDynamicType());
 }
 
 SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::getTypeRTTIMangledName(
     slang::TypeReflection* type, ISlangBlob** outNameBlob)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     auto internalType = asInternal(type);
     if (auto declRefType = as<DeclRefType>(internalType))
     {
-        auto name = getMangledName(internalType->getASTBuilder(), declRefType->declRef);
+        auto name = getMangledName(m_astBuilder, declRefType->getDeclRef());
         Slang::ComPtr<ISlangBlob> blob = Slang::StringUtil::createStringBlob(name);
         *outNameBlob = blob.detach();
         return SLANG_OK;
@@ -1264,9 +1279,11 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::getTypeRTTIMangledName(
 SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::getTypeConformanceWitnessMangledName(
     slang::TypeReflection* type, slang::TypeReflection* interfaceType, ISlangBlob** outNameBlob)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     auto subType = asInternal(type);
     auto supType = asInternal(interfaceType);
-    auto name = getMangledNameForConformanceWitness(subType->getASTBuilder(), subType, supType);
+    auto name = getMangledNameForConformanceWitness(m_astBuilder, subType, supType);
     Slang::ComPtr<ISlangBlob> blob = Slang::StringUtil::createStringBlob(name);
     *outNameBlob = blob.detach();
     return SLANG_OK;
@@ -1277,14 +1294,16 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::getTypeConformanceWitnessSequent
     slang::TypeReflection* interfaceType,
     uint32_t* outId)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     auto subType = asInternal(type);
     auto supType = asInternal(interfaceType);
 
     if (!subType || !supType)
         return SLANG_FAIL;
 
-    auto name = getMangledNameForConformanceWitness(subType->getASTBuilder(), subType, supType);
-    auto interfaceName = getMangledTypeName(supType->getASTBuilder(), supType);
+    auto name = getMangledNameForConformanceWitness(m_astBuilder, subType, supType);
+    auto interfaceName = getMangledTypeName(m_astBuilder, supType);
     uint32_t resultIndex = 0;
     if (mapMangledNameToRTTIObjectIndex.tryGetValue(name, resultIndex))
     {
@@ -1313,6 +1332,8 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::createTypeConformanceComponentTy
     SlangInt conformanceIdOverride,
     ISlangBlob** outDiagnostics)
 {
+    SLANG_AST_BUILDER_RAII(getASTBuilder());
+
     RefPtr<TypeConformance> result;
     DiagnosticSink sink;
     try
@@ -1550,6 +1571,8 @@ CapabilitySet TargetRequest::getTargetCaps()
 
 TypeLayout* TargetRequest::getTypeLayout(Type* type)
 {
+    SLANG_AST_BUILDER_RAII(getLinkage()->getASTBuilder());
+
     // TODO: We are not passing in a `ProgramLayout` here, although one
     // is nominally required to establish the global ordering of
     // generic type parameters, which might be referenced from field types.
@@ -1866,6 +1889,9 @@ Type* ComponentType::getTypeFromString(
     Scope* scope = _createScopeForLegacyLookup(astBuilder);
 
     auto linkage = getLinkage();
+
+    SLANG_AST_BUILDER_RAII(linkage->getASTBuilder());
+
     Expr* typeExpr = linkage->parseTermString(
         typeStr, scope);
     type = checkProperType(linkage, TypeExp(typeExpr), sink);
@@ -2172,6 +2198,8 @@ void FrontEndCompileRequest::parseTranslationUnit(
 {
     auto linkage = getLinkage();
 
+    SLANG_AST_BUILDER_RAII(linkage->getASTBuilder());
+
     // TODO(JS): NOTE! Here we are using the searchDirectories on the linkage. This is because
     // currently the API only allows the setting search paths on linkage.
     //
@@ -2376,6 +2404,8 @@ void FrontEndCompileRequest::checkAllTranslationUnits()
 
 void FrontEndCompileRequest::generateIR()
 {
+    SLANG_AST_BUILDER_RAII(getLinkage()->getASTBuilder());
+
     // Our task in this function is to generate IR code
     // for all of the declarations in the translation
     // units that were loaded.
@@ -2469,6 +2499,8 @@ static SourceLanguage inferSourceLanguage(FrontEndCompileRequest* request)
 
 SlangResult FrontEndCompileRequest::executeActionsInner()
 {
+    SLANG_AST_BUILDER_RAII(getLinkage()->getASTBuilder());
+
     // We currently allow GlSL files on the command line so that we can
     // drive our "pass-through" mode, but we really want to issue an error
     // message if the user is seriously asking us to compile them.
@@ -3272,7 +3304,7 @@ Module::Module(Linkage* linkage, ASTBuilder* astBuilder)
     }
     else
     {
-        m_astBuilder = new ASTBuilder(linkage->getASTBuilder()->getSharedASTBuilder(), "Module");
+        m_astBuilder = linkage->getASTBuilder();
     }
 
     addModuleDependency(this);
@@ -4091,36 +4123,28 @@ struct SpecializationArgModuleCollector : ComponentTypeVisitor
         maybeAddModule(module);
     }
 
-    void collectReferencedModules(Substitutions* substitution)
+    void collectReferencedModules(SubstitutionSet substitutions)
     {
-        if(auto genericSubst = as<GenericSubstitution>(substitution))
+        substitutions.forEachGenericSubstitution([this](GenericDecl*, Val::OperandView<Val> args)
         {
-            for(auto arg : genericSubst->getArgs())
+            for (auto arg : args)
             {
                 collectReferencedModules(arg);
             }
-        }
-    }
-
-    void collectReferencedModules(SubstitutionSet const& substitutions)
-    {
-        for(auto subst = substitutions.substitutions; subst; subst = subst->getOuter())
-        {
-            collectReferencedModules(subst);
-        }
+        });
     }
 
-    void collectReferencedModules(DeclRefBase const& declRef)
+    void collectReferencedModules(DeclRefBase* declRef)
     {
-        collectReferencedModules(declRef.getDecl());
-        collectReferencedModules(declRef.getSubst());
+        collectReferencedModules(declRef->getDecl());
+        collectReferencedModules(SubstitutionSet(declRef));
     }
 
     void collectReferencedModules(Type* type)
     {
         if(auto declRefType = as<DeclRefType>(type))
         {
-            collectReferencedModules(declRefType->declRef);
+            collectReferencedModules(declRefType->getDeclRef());
         }
 
         // TODO: Handle non-decl-ref composite type cases
@@ -4135,7 +4159,7 @@ struct SpecializationArgModuleCollector : ComponentTypeVisitor
         }
         else if (auto declRefVal = as<GenericParamIntVal>(val))
         {
-            collectReferencedModules(declRefVal->declRef);
+            collectReferencedModules(declRefVal->getDeclRef());
         }
 
         // TODO: other cases of values that could reference
@@ -4350,41 +4374,6 @@ SpecializedComponentType::SpecializedComponentType(
         m_moduleDependencies.add(module);
     }
 
-    // The following is a bit of a hack.
-    //
-    // TODO: We should not need this hack any longer, since the
-    // new approach to `switch`-based dynamic dispatch has made
-    // the existing tagged-union support obsolete.
-    //
-    // Back-end code generation relies on us having computed layouts for all tagged
-    // unions that end up being used in the code, which means we need a way to find
-    // all such types that get used in a program (and the stuff it imports).
-    //
-    // For now we are assuming a tagged union type only comes into existence
-    // as a (top-level) argument for a generic type parameter, so that we
-    // can check for them here and cache them on the entry point.
-    //
-    // A longer-term strategy might need to consider any (tagged or untagged)
-    // union types that get used inside of a module, and also take
-    // those lists into account.
-    //
-    // An even longer-term strategy would be to allow type layout to
-    // be performed on IR types, so taht we don't need to have front-end
-    // code worrying about this stuff.
-    //
-    for(auto arg : specializationArgs)
-    {
-        auto argType = as<Type>(arg.val);
-        if(!argType)
-            continue;
-
-        auto taggedUnionType = as<TaggedUnionType>(argType);
-        if(!taggedUnionType)
-            continue;
-
-        m_taggedUnionTypes.add(taggedUnionType);
-    }
-
     // Because we are specializing shader code, the mangled entry
     // point names for this component type may be different than
     // for the base component type (e.g., the mangled name for `f<int>`
diff --git a/source/slang/slang.natvis b/source/slang/slang.natvis
index 74b625183..912a8f2a7 100644
--- a/source/slang/slang.natvis
+++ b/source/slang/slang.natvis
@@ -11,48 +11,66 @@
   </Type>
   <Type Name="Slang::DeclRef&lt;*&gt;">
     <DisplayString Condition="declRefBase == 0">DeclRef nullptr</DisplayString>
+
     <DisplayString Condition="declRefBase != 0">{*declRefBase}</DisplayString>
     <Expand>
-      <ExpandedItem>declRefBase ? ($T1*)(declRefBase->decl) : ($T1*)0</ExpandedItem>
-      <Synthetic Name="[Substitutions]">
-        <Expand>
-            <LinkedListItems>
-                <HeadPointer>declRefBase->substitutions</HeadPointer>
-                <NextPointer>outer</NextPointer>
-                <ValueNode>this</ValueNode>
-            </LinkedListItems>
-        </Expand>
-      </Synthetic>
+      <ExpandedItem>declRefBase</ExpandedItem>
     </Expand>
   </Type>
     <Type Name="Slang::DeclRefBase">
-      <DisplayString Condition="decl != 0 &amp;&amp; substitutions != 0">{*decl}{*substitutions}</DisplayString>
-      <DisplayString Condition="decl != 0">{*decl}</DisplayString>
-      <DisplayString Condition="decl == 0">DeclRefBase nullptr</DisplayString>
-      <Expand>
-          <ExpandedItem>decl</ExpandedItem>
-          <Synthetic Name="[Substitutions]">
-              <Expand>
-                  <LinkedListItems>
-                      <HeadPointer>substitutions.substitutions</HeadPointer>
-                      <NextPointer>outer</NextPointer>
-                      <ValueNode>this</ValueNode>
-                  </LinkedListItems>
-              </Expand>
-          </Synthetic>
-      </Expand>
-    </Type>
-    <Type Name="Slang::GenericSubstitution">
-        <DisplayString>GenSubst {(*genericDecl).nameAndLoc}</DisplayString>
+        <DisplayString Optional="true" Condition="m_operands.m_buffer[0].values.nodeOperand != 0">{astNodeType,en}#{_debugUID}({(Decl*)m_operands.m_buffer[0].values.nodeOperand}) </DisplayString>
+        <DisplayString Condition="m_operands.m_buffer[0].values.nodeOperand != 0">{astNodeType,en}({(Decl*)m_operands.m_buffer[0].values.nodeOperand})</DisplayString>
+        <DisplayString Condition="m_operands.m_buffer[0].values.nodeOperand == 0">DeclRefBase nullptr</DisplayString>
         <Expand>
-            <Item Name="genericDecl">genericDecl</Item>
-            <ExpandedItem>args</ExpandedItem>
+            <Synthetic Name="[Decl]">
+                <DisplayString>{*(Decl*)m_operands.m_buffer[0].values.nodeOperand}</DisplayString>
+                <Expand>
+                    <ExpandedItem>*(Decl*)m_operands.m_buffer[0].values.nodeOperand</ExpandedItem>
+                </Expand>
+            </Synthetic>
+            <Synthetic Condition="astNodeType == Slang::ASTNodeType::MemberDeclRef" Name="[Parent]">
+                <DisplayString>{*(DeclRefBase*)(this->m_operands.m_buffer[1].values.nodeOperand)}</DisplayString>
+                <Expand>
+                    <ExpandedItem>*(DeclRefBase*)(this->m_operands.m_buffer[1].values.nodeOperand)</ExpandedItem>
+                </Expand>
+            </Synthetic>
+            <Synthetic Condition="astNodeType == Slang::ASTNodeType::LookupDeclRef" Name="[Base]">
+                <DisplayString>{*(Val*)(this->m_operands.m_buffer[1].values.nodeOperand)}</DisplayString>
+                <Expand>
+                    <ExpandedItem>*(Val*)(this->m_operands.m_buffer[1].values.nodeOperand)</ExpandedItem>
+                </Expand>
+            </Synthetic>
+            <Synthetic Condition="astNodeType == Slang::ASTNodeType::LookupDeclRef" Name="[Witness]">
+                <DisplayString>{*(SubtypeWitness*)(this->m_operands.m_buffer[2].values.nodeOperand)}</DisplayString>
+                <Expand>
+                    <ExpandedItem>*(SubtypeWitness*)(this->m_operands.m_buffer[2].values.nodeOperand)</ExpandedItem>
+                </Expand>
+            </Synthetic>
+            <Synthetic Condition="astNodeType == Slang::ASTNodeType::GenericAppDeclRef" Name="[BaseGeneric]">
+                <DisplayString>{*(DeclRefBase*)(this->m_operands.m_buffer[1].values.nodeOperand)}</DisplayString>
+                <Expand>
+                    <ExpandedItem>*(DeclRefBase*)(this->m_operands.m_buffer[1].values.nodeOperand)</ExpandedItem>
+                </Expand>
+            </Synthetic>
+            <CustomListItems Condition="astNodeType == Slang::ASTNodeType::GenericAppDeclRef">
+                <Variable Name="index" InitialValue="2"/>
+                <Loop Condition="index&lt;m_operands.m_count">
+                    <Item Name="Arg[{index-2}]">*(Val*)(this->m_operands.m_buffer[index].values.nodeOperand)</Item>
+                    <Exec>index=index+1</Exec>
+                </Loop>
+            </CustomListItems>
         </Expand>
     </Type>
   <Type Name="Slang::DeclRefType">
-    <DisplayString>DeclRefType {declRef}</DisplayString>
+      <DisplayString Optional="true">{astNodeType,en}#{_debugUID} {*(DeclRefBase*)m_operands.m_buffer[0].values.nodeOperand} </DisplayString>
+
+      <DisplayString>{astNodeType,en} {*(DeclRefBase*)m_operands.m_buffer[0].values.nodeOperand}</DisplayString>
     <Expand>
-      <ExpandedItem>declRef</ExpandedItem>
+        <Synthetic Name="DeclRefType">
+            <DisplayString Optional="true">{astNodeType,en}#{_debugUID} {m_operands.m_buffer[0].values.nodeOperand->astNodeType, en}#{m_operands.m_buffer[0].values.nodeOperand->_debugUID}</DisplayString>
+            <DisplayString>{astNodeType,en} {m_operands.m_buffer[0].values.nodeOperand->astNodeType, en}</DisplayString>
+        </Synthetic>
+      <ExpandedItem>*(DeclRefBase*)m_operands.m_buffer[0].values.nodeOperand</ExpandedItem>
     </Expand>
   </Type>
     <Type Name="Slang::FuncDecl">
@@ -223,13 +241,12 @@
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::OpenRefExpr">(Slang::OpenRefExpr*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ForwardDifferentiateExpr">(Slang::ForwardDifferentiateExpr*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BackwardDifferentiateExpr">(Slang::BackwardDifferentiateExpr*)&amp;astNodeType</ExpandedItem>
-            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TaggedUnionTypeExpr">(Slang::TaggedUnionTypeExpr*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ThisTypeExpr">(Slang::ThisTypeExpr*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AndTypeExpr">(Slang::AndTypeExpr*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ModifiedTypeExpr">(Slang::ModifiedTypeExpr*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::PointerTypeExpr">(Slang::PointerTypeExpr*)&amp;astNodeType</ExpandedItem>
             <Item Name="[type]">type</Item>
-            <Item Name="[Expr]">(Slang::Expr*)this,nd</Item>
+            <Item Name="[Expr]">(Slang::Expr*)this,!</Item>
         </Expand>
     </Type>
     <Type Name="Slang::Stmt" Inheritable="false">
@@ -261,18 +278,19 @@
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ContinueStmt">(Slang::ContinueStmt*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ReturnStmt">(Slang::ReturnStmt*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExpressionStmt">(Slang::ExpressionStmt*)&amp;astNodeType</ExpandedItem>
-            <Item Name="[Stmt]">(Slang::Stmt*)this,nd</Item>
+            <Item Name="[Stmt]">(Slang::Stmt*)this,!</Item>
         </Expand>
     </Type>
     <Type Name="Slang::Name">
         <DisplayString>{text}</DisplayString>
     </Type>
     <Type Name="Slang::Decl" Inheritable="false">
-        <DisplayString Condition="nameAndLoc.name!=0">{nameAndLoc.name->text}</DisplayString>
+        <DisplayString Condition="nameAndLoc.name!=0">{astNodeType,en} {nameAndLoc.name->text}</DisplayString>
         <DisplayString Condition="nameAndLoc.name==0">{astNodeType,en}</DisplayString>
         <Expand>
             <Item Name="[Name]" Condition="nameAndLoc.name!=0">nameAndLoc.name->text</Item>
             <Item Name="[Parent]">parentDecl</Item>
+            <Item Name="[CheckState]">Slang::DeclCheckState(checkState.m_raw &amp; ~Slang::DeclCheckStateExt::kBeingCheckedBit)</Item>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ContainerDecl">(Slang::ContainerDecl*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExtensionDecl">(Slang::ExtensionDecl*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::StructDecl">(Slang::StructDecl*)&amp;astNodeType</ExpandedItem>
@@ -314,7 +332,7 @@
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SyntaxDecl">(Slang::SyntaxDecl*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DeclGroup">(Slang::DeclGroup*)&amp;astNodeType</ExpandedItem>
             
-            <Item Name="Decl">(Slang::DeclBase*)this,nd</Item>
+            <Item Name="Decl">(Slang::DeclBase*)this,!</Item>
         </Expand>
     </Type>
 
@@ -361,20 +379,57 @@
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::EmptyDecl">(Slang::EmptyDecl*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SyntaxDecl">(Slang::SyntaxDecl*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DeclGroup">(Slang::DeclGroup*)&amp;astNodeType</ExpandedItem>
-            <Item Name="Decl">(Slang::Decl*)this,nd</Item>
+            <Item Name="Decl">(Slang::Decl*)this,!</Item>
         </Expand>
     </Type>
+    <Type Name="Slang::TypeType" Inheritable="false">
+        <DisplayString Optional="true">{astNodeType,en} #{_debugUID} {*(Val*)(((Slang::DeclRefType*)this)->m_operands.m_buffer[0].values.nodeOperand)}</DisplayString>
+        <DisplayString>{astNodeType,en} {*(Val*)(((Slang::DeclRefType*)this)->m_operands.m_buffer[0].values.nodeOperand)}</DisplayString>
+        <Expand>
+            <ExpandedItem>*(Val*)(((Slang::DeclRefType*)this)->m_operands.m_buffer[0].values.nodeOperand)</ExpandedItem>
+        </Expand>
+    </Type>
+    <Type Name="Slang::FuncType" Inheritable="false">
+        <DisplayString Optional="true">{astNodeType,en} #{_debugUID}</DisplayString>
+        <DisplayString Optional="true">{astNodeType,en}</DisplayString>
+        <Expand>
+            <Synthetic Name="[ParamCount]">
+                <DisplayString>{m_operands.m_count-2}</DisplayString>
+            </Synthetic>
+            <ArrayItems>
+                <Size>m_operands.m_count-2</Size>
+                <ValuePointer>m_operands.m_buffer</ValuePointer>
+            </ArrayItems>
+            <Synthetic Name="[ResultType]">
+                <DisplayString>{m_operands.m_buffer[m_operands.m_count-2]}</DisplayString>
+                <Expand>
+                    <ExpandedItem>m_operands.m_buffer[m_operands.m_count-2]</ExpandedItem>
+                </Expand>
+            </Synthetic>
+            <Synthetic Name="[ErrorType]">
+                <DisplayString>{m_operands.m_buffer[m_operands.m_count-1]}</DisplayString>
+                <Expand>
+                    <ExpandedItem>m_operands.m_buffer[m_operands.m_count-1]</ExpandedItem>
+                </Expand>
+            </Synthetic>
+        </Expand>
 
+    </Type>
     <Type Name="Slang::Type" Inheritable="false">
-      <DisplayString Condition="astNodeType == Slang::ASTNodeType::DeclRefType">{((Slang::DeclRefType*)&amp;astNodeType)->declRef}</DisplayString>
+      <DisplayString Optional="true" Condition="astNodeType == Slang::ASTNodeType::DeclRefType">DeclRefType#{_debugUID} {*(Val*)(((Slang::DeclRefType*)this)->m_operands.m_buffer[0].values.nodeOperand)}</DisplayString>
+      <DisplayString Condition="astNodeType == Slang::ASTNodeType::DeclRefType">DeclRefType {*(Val*)(((Slang::DeclRefType*)this)->m_operands.m_buffer[0].values.nodeOperand)}</DisplayString>
+      <DisplayString Optional="true">{astNodeType,en} #{_debugUID}</DisplayString>
       <DisplayString>{astNodeType,en}</DisplayString>
-      <Expand>
+
+        <Expand>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::OverloadGroupType">(Slang::OverloadGroupType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::InitializerListType">(Slang::InitializerListType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ErrorType">(Slang::ErrorType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BottomType">(Slang::BottomType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DeclRefType">(Slang::DeclRefType*)&amp;astNodeType</ExpandedItem>
-            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DifferentialPairType">(Slang::DeclRefType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DifferentiableType">(Slang::DeclRefType*)&amp;astNodeType</ExpandedItem>
+
+          <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DifferentialPairType">(Slang::DeclRefType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ArithmeticExpressionType">(Slang::ArithmeticExpressionType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BasicExpressionType">(Slang::BasicExpressionType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::VectorExpressionType">(Slang::VectorExpressionType*)&amp;astNodeType</ExpandedItem>
@@ -437,45 +492,51 @@
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ArrayExpressionType">(Slang::ArrayExpressionType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TypeType">(Slang::TypeType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NamedExpressionType">(Slang::NamedExpressionType*)&amp;astNodeType</ExpandedItem>
-            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::FuncType">(Slang::FuncType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::FuncType">(Slang::FuncType*)this</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericDeclRefType">(Slang::GenericDeclRefType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NamespaceType">(Slang::NamespaceType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExtractExistentialType">(Slang::ExtractExistentialType*)&amp;astNodeType</ExpandedItem>
-            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TaggedUnionType">(Slang::TaggedUnionType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExistentialSpecializedType">(Slang::ExistentialSpecializedType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ThisType">(Slang::ThisType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AndType">(Slang::AndType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ModifiedType">(Slang::ModifiedType*)&amp;astNodeType</ExpandedItem>
             
-            <Item Name="[Type]">(Slang::Type*)this,nd</Item>
-        </Expand>
-    </Type>
-    <Type Name="Slang::Substitutions" Inheritable="false">
-      <DisplayString Condition="astNodeType == Slang::ASTNodeType::GenericSubstitution">{*(Slang::GenericSubstitution*)&amp;astNodeType}</DisplayString>
-      <DisplayString Condition="astNodeType == Slang::ASTNodeType::ThisTypeSubstitution">{*(Slang::ThisTypeSubstitution*)&amp;astNodeType}</DisplayString>
-      <DisplayString>{astNodeType,en}</DisplayString>
-      <DisplayString>{astNodeType,en}</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericSubstitution">(Slang::GenericSubstitution*)&amp;astNodeType</ExpandedItem>
-            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ThisTypeSubstitution">(Slang::ThisTypeSubstitution*)&amp;astNodeType</ExpandedItem>
+            <Item Name="[Raw View]">(Slang::Type*)this,!</Item>
         </Expand>
     </Type>
-    <Type Name="Slang::GenericSubstitution" Inheritable="false">
-      <DisplayString Condition="outer != 0">&lt;{args}&gt;{*outer}</DisplayString>
-      <DisplayString>&lt;{args}&gt;</DisplayString>
-    </Type>
-    <Type Name="Slang::ThisTypeSubstitution" Inheritable="false">
-      <DisplayString Condition="outer != 0">{*outer}[This=={witness->sub,na}]</DisplayString>
-      <DisplayString>[{witness->sup,na}.This: {witness->sub,na}]</DisplayString>
-    </Type>
     <Type Name="Slang::SubstitutionSet">
-        <DisplayString>{astNodeType,en}</DisplayString>
+        <DisplayString>SubstitutionSet{declRef,en}</DisplayString>
         <Expand>
-            <LinkedListItems>
-                <HeadPointer>substitutions</HeadPointer>
-                <NextPointer>outer</NextPointer>
-                <ValueNode>(Slang::Substitutions*)this</ValueNode>
-            </LinkedListItems>
+            <ExpandedItem>declRef</ExpandedItem>
+            <CustomListItems MaxItemsPerView="24">
+                <Variable Name="subst" InitialValue="declRef"/>
+                <Variable Name="substType" InitialValue="(Slang::ASTNodeType)0"/>
+                <Variable Name="shouldBreak" InitialValue="0"/>
+                <Loop Condition="subst != 0">
+                    <Exec>substType = subst->astNodeType </Exec>
+                    <Exec>shouldBreak = 1 </Exec>
+
+                    <If Condition="substType == Slang::ASTNodeType::DirectDeclRef">
+                        <Break/>
+                    </If>
+                    <If Condition="substType == Slang::ASTNodeType::MemberDeclRef">
+                        <Exec>subst = (DeclRefBase*)(((Slang::MemberDeclRef*)subst)->m_operands.m_buffer[1].values.nodeOperand)</Exec>
+                        <Exec>shouldBreak = 0 </Exec>
+                    </If>
+                    <If Condition="substType == Slang::ASTNodeType::LookupDeclRef">
+                        <Item>(LookupDeclRef*)subst</Item>
+                        <Break/>
+                    </If>
+                    <If Condition="substType == Slang::ASTNodeType::GenericAppDeclRef">
+                        <Item>(GenericAppDeclRef*)subst</Item>
+                        <Exec>subst = (DeclRefBase*)(((Slang::GenericAppDeclRef*)subst)->m_operands.m_buffer[1].values.nodeOperand)</Exec>
+                        <Exec>shouldBreak = 0 </Exec>
+                    </If>
+                    <If Condition="shouldBreak">
+                        <Break/>
+                    </If>
+                </Loop>
+            </CustomListItems>
         </Expand>
     </Type>
     <Type Name="Slang::AggTypeDecl">
@@ -484,9 +545,103 @@
             <Item Name="[Members]">members</Item>
         </Expand>
     </Type>
+    <Type Name="Slang::ValNodeOperand">
+        <DisplayString Condition="kind==Slang::ValNodeOperandKind::ConstantValue">Const({values.intOperand})</DisplayString>
+        <DisplayString Condition="kind==Slang::ValNodeOperandKind::ValNode">{*(Val*)values.nodeOperand}</DisplayString>
+        <DisplayString>{values.nodeOperand}</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="kind==Slang::ValNodeOperandKind::ValNode">*(Val*)values.nodeOperand</ExpandedItem>
+            <ExpandedItem Condition="kind==Slang::ValNodeOperandKind::ASTNode">*values.nodeOperand</ExpandedItem>
+        </Expand>
+    </Type>
     <Type Name="Slang::Val" Inheritable="false">
-        <DisplayString>{astNodeType,en}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::DirectDeclRef">{*(Slang::DirectDeclRef*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::LookupDeclRef">{*(Slang::LookupDeclRef*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::MemberDeclRef">{*(Slang::MemberDeclRef*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::GenericAppDeclRef">{*(Slang::GenericAppDeclRef*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ConstantIntVal">{*(Slang::ConstantIntVal*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::PolynomialIntVal">{*(Slang::PolynomialIntVal*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::GenericParamIntVal">{*(Slang::GenericParamIntVal*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::DeclaredSubtypeWitness">{*(Slang::DeclaredSubtypeWitness*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::TransitiveSubtypeWitness">{*(Slang::TransitiveSubtypeWitness*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::OverloadGroupType">{*(Slang::OverloadGroupType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::InitializerListType">{*(Slang::InitializerListType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ErrorType">{*(Slang::ErrorType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::BottomType">{*(Slang::BottomType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::DeclRefType">{*(Slang::DeclRefType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::DifferentialPairType">{*(Slang::DeclRefType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ArithmeticExpressionType">{*(Slang::ArithmeticExpressionType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::BasicExpressionType">{*(Slang::BasicExpressionType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::VectorExpressionType">{*(Slang::VectorExpressionType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::MatrixExpressionType">{*(Slang::MatrixExpressionType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::BuiltinType">{*(Slang::BuiltinType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::FeedbackType">{*(Slang::FeedbackType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ResourceType">{*(Slang::ResourceType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::TextureTypeBase">{*(Slang::TextureTypeBase*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::TextureType">{*(Slang::TextureType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::TextureSamplerType">{*(Slang::TextureSamplerType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::GLSLImageType">{*(Slang::GLSLImageType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::SamplerStateType">{*(Slang::SamplerStateType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::BuiltinGenericType">{*(Slang::BuiltinGenericType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::PointerLikeType">{*(Slang::PointerLikeType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ParameterGroupType">{*(Slang::ParameterGroupType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::UniformParameterGroupType">{*(Slang::UniformParameterGroupType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ConstantBufferType">{*(Slang::ConstantBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::TextureBufferType">{*(Slang::TextureBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::GLSLShaderStorageBufferType">{*(Slang::GLSLShaderStorageBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ParameterBlockType">{*(Slang::ParameterBlockType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::VaryingParameterGroupType">{*(Slang::VaryingParameterGroupType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::GLSLInputParameterGroupType">{*(Slang::GLSLInputParameterGroupType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::GLSLOutputParameterGroupType">{*(Slang::GLSLOutputParameterGroupType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLStructuredBufferTypeBase">{*(Slang::HLSLStructuredBufferTypeBase*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLStructuredBufferType">{*(Slang::HLSLStructuredBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLRWStructuredBufferType">{*(Slang::HLSLRWStructuredBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLRasterizerOrderedStructuredBufferType">{*(Slang::HLSLRasterizerOrderedStructuredBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLAppendStructuredBufferType">{*(Slang::HLSLAppendStructuredBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLConsumeStructuredBufferType">{*(Slang::HLSLConsumeStructuredBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLStreamOutputType">{*(Slang::HLSLStreamOutputType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLPointStreamType">{*(Slang::HLSLPointStreamType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLLineStreamType">{*(Slang::HLSLLineStreamType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLTriangleStreamType">{*(Slang::HLSLTriangleStreamType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::UntypedBufferResourceType">{*(Slang::UntypedBufferResourceType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLByteAddressBufferType">{*(Slang::HLSLByteAddressBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLRWByteAddressBufferType">{*(Slang::HLSLRWByteAddressBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLRasterizerOrderedByteAddressBufferType">{*(Slang::HLSLRasterizerOrderedByteAddressBufferType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::RaytracingAccelerationStructureType">{*(Slang::RaytracingAccelerationStructureType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLPatchType">{*(Slang::HLSLPatchType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLInputPatchType">{*(Slang::HLSLInputPatchType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::HLSLOutputPatchType">{*(Slang::HLSLOutputPatchType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::GLSLInputAttachmentType">{*(Slang::GLSLInputAttachmentType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::StringTypeBase">{*(Slang::StringTypeBase*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::StringType">{*(Slang::StringType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::NativeStringType">{*(Slang::NativeStringType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::DynamicType">{*(Slang::DynamicType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::EnumTypeType">{*(Slang::EnumTypeType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::PtrTypeBase">{*(Slang::PtrTypeBase*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::PtrType">{*(Slang::PtrType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ParamDirectionType">{(Slang::ParamDirectionType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::OutTypeBase">{*(Slang::OutTypeBase*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::OutType">{*(Slang::OutType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::InOutType">{*(Slang::InOutType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::RefType">{*(Slang::RefType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::NullPtrType">{*(Slang::NullPtrType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ArrayExpressionType">{*(Slang::ArrayExpressionType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::TypeType">{*(Slang::TypeType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::NamedExpressionType">{*(Slang::NamedExpressionType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::FuncType">{*(Slang::FuncType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::GenericDeclRefType">{*(Slang::GenericDeclRefType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::NamespaceType">{*(Slang::NamespaceType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ExtractExistentialType">{*(Slang::ExtractExistentialType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ExistentialSpecializedType">{*(Slang::ExistentialSpecializedType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ThisType">{*(Slang::ThisType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::AndType">{*(Slang::AndType*)this}</DisplayString>
+        <DisplayString Condition="astNodeType == Slang::ASTNodeType::ModifiedType">{*(Slang::ModifiedType*)this}</DisplayString>
+        
         <Expand>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DirectDeclRef">(Slang::DirectDeclRef*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::LookupDeclRef">(Slang::LookupDeclRef*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::MemberDeclRef">(Slang::MemberDeclRef*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericAppDeclRef">(Slang::GenericAppDeclRef*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ConstantIntVal">(Slang::ConstantIntVal*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::PolynomialIntVal">(Slang::PolynomialIntVal*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericParamIntVal">(Slang::GenericParamIntVal*)&amp;astNodeType</ExpandedItem>
@@ -560,11 +715,15 @@
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericDeclRefType">(Slang::GenericDeclRefType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NamespaceType">(Slang::NamespaceType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExtractExistentialType">(Slang::ExtractExistentialType*)&amp;astNodeType</ExpandedItem>
-            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TaggedUnionType">(Slang::TaggedUnionType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExistentialSpecializedType">(Slang::ExistentialSpecializedType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ThisType">(Slang::ThisType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AndType">(Slang::AndType*)&amp;astNodeType</ExpandedItem>
             <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ModifiedType">(Slang::ModifiedType*)&amp;astNodeType</ExpandedItem>
+            <Synthetic Name="[RawOperands]">
+                <Expand>
+                    <ExpandedItem>m_operands</ExpandedItem>
+                </Expand>
+            </Synthetic>
         </Expand>
     </Type>
     <Type Name="Slang::Facet">
@@ -594,7 +753,41 @@
   </Type>
   <Type Name="Slang::SubtypeWitness">
     <DisplayString Condition="astNodeType == Slang::ASTNodeType::TypeEqualityWitness">{*(Slang::TypeEqualityWitness*)this}</DisplayString>
-    <DisplayString>{sub,na} &lt;: {sup,na}</DisplayString>
+    <DisplayString Optional="true">{astNodeType,en}#{_debugUID}({*(Type*)m_operands.m_buffer[0].values.nodeOperand,na} &lt;: {*(Type*)m_operands.m_buffer[1].values.nodeOperand,na})</DisplayString>
+    <DisplayString>{astNodeType,en}({*(Type*)m_operands.m_buffer[0].values.nodeOperand,na} &lt;: {*(Type*)m_operands.m_buffer[1].values.nodeOperand,na})</DisplayString>
+     
+    <Expand>
+        <Synthetic Name="[Sub]">
+            <DisplayString>{*(Type*)m_operands.m_buffer[0].values.nodeOperand}</DisplayString>
+            <Expand>
+                <ExpandedItem>(Type*)m_operands.m_buffer[0].values.nodeOperand</ExpandedItem>
+            </Expand>
+        </Synthetic>
+        <Synthetic Name="[Sup]">
+            <DisplayString>{*(Type*)m_operands.m_buffer[1].values.nodeOperand}</DisplayString>
+            <Expand>
+                <ExpandedItem>(Type*)m_operands.m_buffer[1].values.nodeOperand</ExpandedItem>
+            </Expand>
+        </Synthetic>
+        <Synthetic Name="[DeclRef]" Condition="astNodeType == Slang::ASTNodeType::DeclaredSubtypeWitness">
+            <DisplayString>{*(Val*)m_operands.m_buffer[2].values.nodeOperand}</DisplayString>
+            <Expand>
+                <ExpandedItem>(DeclRefBase*)m_operands.m_buffer[2].values.nodeOperand</ExpandedItem>
+            </Expand>
+        </Synthetic>
+        <Synthetic Name="[SubToMid]" Condition="astNodeType == Slang::ASTNodeType::TransitiveSubtypeWitness">
+            <DisplayString>{*(SubtypeWitness*)m_operands.m_buffer[2].values.nodeOperand}</DisplayString>
+            <Expand>
+                <ExpandedItem>(SubtypeWitness*)m_operands.m_buffer[2].values.nodeOperand</ExpandedItem>
+            </Expand>
+        </Synthetic>
+        <Synthetic Name="[MidToSup]" Condition="astNodeType == Slang::ASTNodeType::TransitiveSubtypeWitness">
+            <DisplayString>{*(SubtypeWitness*)m_operands.m_buffer[3].values.nodeOperand}</DisplayString>
+            <Expand>
+                <ExpandedItem>(SubtypeWitness*)m_operands.m_buffer[3].values.nodeOperand</ExpandedItem>
+            </Expand>
+        </Synthetic>
+    </Expand>
   </Type>
   <Type Name="Slang::TypeEqualityWitness">
     <DisplayString>{sub,na} == {sup,na}</DisplayString>