Attachment 358157 Details for Bug 193007 – Patch

[patch] Patch

patch.txt (text/plain), 162.81 KB, created by Myles C. Maxfield on 2018-12-31 17:41:23 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Myles C. Maxfield

Created: 2018-12-31 17:41:23 PST

Size: 162.81 KB

patch

obsolete

>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLArrayReferenceType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLArrayReferenceType.h
>index 2d567f00e70..eb390e42e7f 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLArrayReferenceType.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLArrayReferenceType.h
>@@ -39,8 +39,8 @@ namespace AST {
> 
> class ArrayReferenceType : public ReferenceType {
> public:
>-    ArrayReferenceType(Lexer::Token&& origin, String&& addressSpace, std::unique_ptr<Type>&& elementType)
>-        : ReferenceType(WTFMove(origin), WTFMove(addressSpace), WTFMove(elementType))
>+    ArrayReferenceType(Lexer::Token&& origin, AddressSpace addressSpace, std::unique_ptr<UnnamedType>&& elementType)
>+        : ReferenceType(WTFMove(origin), addressSpace, WTFMove(elementType))
>     {
>     }
> 
>@@ -49,11 +49,11 @@ public:
>     ArrayReferenceType(const ArrayReferenceType&) = delete;
>     ArrayReferenceType(ArrayReferenceType&&) = default;
> 
>-    bool isArrayReferenceType() const override { return false; }
>+    bool isArrayReferenceType() const override { return true; }
> 
>-    std::unique_ptr<Type> clone() const override
>+    std::unique_ptr<UnnamedType> clone() const override
>     {
>-        return std::make_unique<ArrayReferenceType>(Lexer::Token(origin()), String(addressSpace()), elementType().clone());
>+        return std::make_unique<ArrayReferenceType>(Lexer::Token(origin()), addressSpace(), elementType().clone());
>     }
> 
> private:
>@@ -65,6 +65,6 @@ private:
> 
> }
> 
>-SPECIALIZE_TYPE_TRAITS_WHLSL_TYPE(ArrayReferenceType, isArrayReferenceType())
>+SPECIALIZE_TYPE_TRAITS_WHLSL_UNNAMED_TYPE(ArrayReferenceType, isArrayReferenceType())
> 
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLArrayType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLArrayType.h
>index 40b5f8df6fe..a2871404cd5 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLArrayType.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLArrayType.h
>@@ -28,7 +28,7 @@
> #if ENABLE(WEBGPU)
> 
> #include "WHLSLLexer.h"
>-#include "WHLSLType.h"
>+#include "WHLSLUnnamedType.h"
> #include "WHLSLTypeArgument.h"
> #include <wtf/text/WTFString.h>
> 
>@@ -38,10 +38,10 @@ namespace WHLSL {
> 
> namespace AST {
> 
>-class ArrayType : public Type {
>+class ArrayType : public UnnamedType {
> public:
>-    ArrayType(Lexer::Token&& origin, std::unique_ptr<Type>&& elementType, unsigned numElements)
>-        : m_origin(WTFMove(origin))
>+    ArrayType(Lexer::Token&& origin, std::unique_ptr<UnnamedType>&& elementType, unsigned numElements)
>+        : UnnamedType(WTFMove(origin))
>         , m_elementType(WTFMove(elementType))
>         , m_numElements(numElements)
>     {
>@@ -52,20 +52,19 @@ public:
>     ArrayType(const ArrayType&) = delete;
>     ArrayType(ArrayType&&) = default;
> 
>-    unsigned numElements() const { return m_numElements; }
>-
>-    bool isArrayType() const override { return false; }
>+    bool isArrayType() const override { return true; }
> 
>-    Type& type() { return *m_elementType; }
>+    UnnamedType& type() { return *m_elementType; }
>+    const UnnamedType& type() const { return *m_elementType; }
>+    unsigned numElements() const { return m_numElements; }
> 
>-    std::unique_ptr<Type> clone() const override
>+    std::unique_ptr<UnnamedType> clone() const override
>     {
>-        return std::make_unique<ArrayType>(Lexer::Token(m_origin), m_elementType->clone(), m_numElements);
>+        return std::make_unique<ArrayType>(Lexer::Token(origin()), m_elementType->clone(), m_numElements);
>     }
> 
> private:
>-    Lexer::Token m_origin;
>-    std::unique_ptr<Type> m_elementType;
>+    std::unique_ptr<UnnamedType> m_elementType;
>     unsigned m_numElements;
> };
> 
>@@ -75,6 +74,6 @@ private:
> 
> }
> 
>-SPECIALIZE_TYPE_TRAITS_WHLSL_TYPE(ArrayType, isArrayType())
>+SPECIALIZE_TYPE_TRAITS_WHLSL_UNNAMED_TYPE(ArrayType, isArrayType())
> 
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLCallExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLCallExpression.h
>index 64af713299c..8b2bdaf4bf6 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLCallExpression.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLCallExpression.h
>@@ -28,6 +28,7 @@
> #if ENABLE(WEBGPU)
> 
> #include "WHLSLExpression.h"
>+#include "WHLSLFunctionDeclaration.h"
> #include "WHLSLLexer.h"
> 
> namespace WebCore {
>@@ -54,9 +55,31 @@ public:
> 
>     Vector<std::unique_ptr<Expression>>& arguments() { return m_arguments; }
> 
>+    String& name() { return m_name; }
>+
>+    void setCastData()
>+    {
>+        // FIXME: Implement this
>+    }
>+
>+    bool hasOverloads() const { return static_cast<bool>(m_overloads); }
>+    void setOverloads(const Vector<std::reference_wrapper<FunctionDeclaration>, 1>& overloads)
>+    {
>+        assert(!hasOverloads());
>+        m_overloads = overloads;
>+    }
>+
>+    void setFunction(FunctionDeclaration& functionDeclaration)
>+    {
>+        assert(!m_function);
>+        m_function = &functionDeclaration;
>+    }
>+
> private:
>     String m_name;
>     Vector<std::unique_ptr<Expression>> m_arguments;
>+    Optional<Vector<std::reference_wrapper<FunctionDeclaration>, 1>> m_overloads;
>+    FunctionDeclaration* m_function { nullptr };
> };
> 
> }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLConstantExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLConstantExpression.h
>index a38b0d5b3a1..f042053247c 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLConstantExpression.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLConstantExpression.h
>@@ -76,11 +76,69 @@ public:
>     {
>     }
> 
>+    IntegerLiteral& integerLiteral()
>+    {
>+        ASSERT(WTF::holds_alternative<IntegerLiteral>(m_variant));
>+        return WTF::get<IntegerLiteral>(m_variant);
>+    }
>+
>     template<typename T> void visit(T&& t)
>     {
>         WTF::visit(WTFMove(t), m_variant);
>     }
> 
>+    template<typename T> void visit(T&& t) const
>+    {
>+        WTF::visit(WTFMove(t), m_variant);
>+    }
>+
>+    bool matches(const ConstantExpression& other) const
>+    {
>+        Optional<bool> result;
>+        double value;
>+        visit(WTF::makeVisitor([&](const IntegerLiteral& integerLiteral) {
>+            value = integerLiteral.value();
>+        }, [&](const UnsignedIntegerLiteral& unsignedIntegerLiteral) {
>+            value = unsignedIntegerLiteral.value();
>+        }, [&](const FloatLiteral& floatLiteral) {
>+            value = floatLiteral.value();
>+        }, [&](const NullLiteral&) {
>+            result = WTF::holds_alternative<NullLiteral>(other.m_variant);
>+        }, [&](const BooleanLiteral& booleanLiteral) {
>+            if (WTF::holds_alternative<BooleanLiteral>(other.m_variant)) {
>+                const auto& otherBooleanLiteral = WTF::get<BooleanLiteral>(other.m_variant);
>+                result = booleanLiteral.value() == otherBooleanLiteral.value();
>+            } else
>+                result = false;
>+        }, [&](const ConstantExpressionEnumerationMemberReference& constantExpressionEnumerationMemberReference) {
>+            if (WTF::holds_alternative<ConstantExpressionEnumerationMemberReference>(other.m_variant)) {
>+                const auto& otherMemberReference = WTF::get<ConstantExpressionEnumerationMemberReference>(other.m_variant);
>+                result = &constantExpressionEnumerationMemberReference.enumerationMember() == &otherMemberReference.enumerationMember();
>+            } else
>+                result = false;
>+        }));
>+
>+        if (result)
>+            return *result;
>+
>+        other.visit(WTF::makeVisitor([&](const IntegerLiteral& integerLiteral) {
>+            result = value == integerLiteral.value();
>+        }, [&](const UnsignedIntegerLiteral& unsignedIntegerLiteral) {
>+            result = value == unsignedIntegerLiteral.value();
>+        }, [&](const FloatLiteral& floatLiteral) {
>+            result = value == floatLiteral.value();
>+        }, [&](const NullLiteral&) {
>+            result = false;
>+        }, [&](const BooleanLiteral&) {
>+            result = false;
>+        }, [&](const ConstantExpressionEnumerationMemberReference&) {
>+            result = false;
>+        }));
>+
>+        ASSERT(result);
>+        return *result;
>+    }
>+
> private:
>     Variant<
>         IntegerLiteral,
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLConstantExpressionEnumerationMemberReference.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLConstantExpressionEnumerationMemberReference.h
>index 2c24a98b2ca..2100d7ca40a 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLConstantExpressionEnumerationMemberReference.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLConstantExpressionEnumerationMemberReference.h
>@@ -36,10 +36,12 @@ namespace WHLSL {
> 
> namespace AST {
> 
>-class ConstantExpressionEnumerationMemberReference : public Node {
>+class EnumerationMember;
>+
>+class ConstantExpressionEnumerationMemberReference : public Expression {
> public:
>     ConstantExpressionEnumerationMemberReference(Lexer::Token&& origin, String&& left, String&& right)
>-        : m_origin(WTFMove(origin))
>+        : Expression(WTFMove(origin))
>         , m_left(WTFMove(left))
>         , m_right(WTFMove(right))
>     {
>@@ -50,10 +52,30 @@ public:
>     explicit ConstantExpressionEnumerationMemberReference(const ConstantExpressionEnumerationMemberReference&) = default;
>     ConstantExpressionEnumerationMemberReference(ConstantExpressionEnumerationMemberReference&&) = default;
> 
>+    const String& left() const { return m_left; }
>+    const String& right() const { return m_right; }
>+
>+    AST::EnumerationMember& enumerationMember()
>+    {
>+        ASSERT(m_enumerationMember);
>+        return *m_enumerationMember;
>+    }
>+
>+    const AST::EnumerationMember& enumerationMember() const
>+    {
>+        ASSERT(m_enumerationMember);
>+        return *m_enumerationMember;
>+    }
>+
>+    void setEnumerationMember(AST::EnumerationMember& enumerationMember)
>+    {
>+        m_enumerationMember = &enumerationMember;
>+    }
>+
> private:
>-    Lexer::Token m_origin;
>     String m_left;
>     String m_right;
>+    AST::EnumerationMember* m_enumerationMember { nullptr };
> };
> 
> }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLDotExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLDotExpression.h
>index c43c69ee541..ebf72326cd0 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLDotExpression.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLDotExpression.h
>@@ -49,6 +49,25 @@ public:
>     DotExpression(const DotExpression&) = delete;
>     DotExpression(DotExpression&&) = default;
> 
>+    bool isDotExpression() const override { return true; }
>+
>+    String getFunctionName() const override
>+    {
>+        return String::format("operator.%s", m_fieldName.utf8().data());
>+    }
>+
>+    String setFunctionName() const override
>+    {
>+        return String::format("operator.%s=", m_fieldName.utf8().data());
>+    }
>+
>+    String andFunctionName() const override
>+    {
>+        return String::format("operator&.%s", m_fieldName.utf8().data());
>+    }
>+
>+    String& fieldName() { return m_fieldName; }
>+
> private:
>     String m_fieldName;
> };
>@@ -59,4 +78,6 @@ private:
> 
> }
> 
>+SPECIALIZE_TYPE_TRAITS_WHLSL_EXPRESSION(DotExpression, isDotExpression())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationDefinition.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationDefinition.h
>index 7970b59e54a..1b8f14528b4 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationDefinition.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationDefinition.h
>@@ -29,7 +29,8 @@
> 
> #include "WHLSLEnumerationMember.h"
> #include "WHLSLLexer.h"
>-#include "WHLSLType.h"
>+#include "WHLSLNamedType.h"
>+#include <wtf/HashMap.h>
> #include <wtf/Vector.h>
> #include <wtf/text/WTFString.h>
> 
>@@ -39,13 +40,11 @@ namespace WHLSL {
> 
> namespace AST {
> 
>-class EnumerationDefinition : public Node {
>+class EnumerationDefinition : public NamedType {
> public:
>-    EnumerationDefinition(Lexer::Token&& origin, String&& name, std::unique_ptr<Type>&& type, EnumerationMembers&& members)
>-        : m_origin(WTFMove(origin))
>-        , m_name(WTFMove(name))
>+    EnumerationDefinition(Lexer::Token&& origin, String&& name, std::unique_ptr<UnnamedType>&& type)
>+        : NamedType(WTFMove(origin), WTFMove(name))
>         , m_type(WTFMove(type))
>-        , m_members(WTFMove(members))
>     {
>     }
> 
>@@ -54,14 +53,35 @@ public:
>     EnumerationDefinition(const EnumerationDefinition&) = delete;
>     EnumerationDefinition(EnumerationDefinition&&) = default;
> 
>-    Type& type() { return *m_type; }
>-    EnumerationMembers& enumerationMembers() { return m_members; }
>+    bool isEnumerationDefinition() const override { return true; }
>+
>+    UnnamedType& type() { return *m_type; }
>+
>+    bool add(EnumerationMember&& member)
>+    {
>+        auto result = m_members.add(member.name(), std::make_unique<EnumerationMember>(WTFMove(member)));
>+        return !result.isNewEntry;
>+    }
>+
>+    EnumerationMember* memberByName(const String& name)
>+    {
>+        auto iterator = m_members.find(name);
>+        if (iterator == m_members.end())
>+            return nullptr;
>+        return iterator->value.get();
>+    }
>+
>+    Vector<std::reference_wrapper<EnumerationMember>> enumerationMembers()
>+    {
>+        Vector<std::reference_wrapper<EnumerationMember>> result;
>+        for (auto& pair : m_members)
>+            result.append(*pair.value);
>+        return result;
>+    }
> 
> private:
>-    Lexer::Token m_origin;
>-    String m_name;
>-    std::unique_ptr<Type> m_type;
>-    EnumerationMembers m_members;
>+    std::unique_ptr<UnnamedType> m_type;
>+    HashMap<String, std::unique_ptr<EnumerationMember>> m_members;
> };
> 
> }
>@@ -70,4 +90,6 @@ private:
> 
> }
> 
>+SPECIALIZE_TYPE_TRAITS_WHLSL_NAMED_TYPE(EnumerationDefinition, isEnumerationDefinition())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationMember.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationMember.h
>index 9d9d854883e..4f385195508 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationMember.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationMember.h
>@@ -54,6 +54,7 @@ public:
>     EnumerationMember(const EnumerationMember&) = delete;
>     EnumerationMember(EnumerationMember&&) = default;
> 
>+    String& name() { return m_name; }
>     Optional<ConstantExpression>& value() { return m_value; }
> 
> private:
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationMemberLiteral.h
>similarity index 62%
>rename from Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp
>rename to Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationMemberLiteral.h
>index 780d5c5425a..c9e96293980 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationMemberLiteral.h
>@@ -23,23 +23,40 @@
>  * THE POSSIBILITY OF SUCH DAMAGE.
>  */
> 
>-#if ENABLE(WEBGPU)
>+#pragma once
> 
>-#include "config.h"
>-#include "WHLSLNameResolver.h"
>+#if ENABLE(WEBGPU)
> 
>-#include "WHLSLVisitor.h"
>+#include "WHLSLEnumerationMember.h"
>+#include "WHLSLExpression.h"
>+#include "WHLSLLexer.h"
> 
> namespace WebCore {
> 
> namespace WHLSL {
> 
>-class NameResolver : public Visitor {
>-    ~NameResolver() = default;
>-};
>+namespace AST {
>+
>+class EnumerationMemberLiteral : public Expression {
>+public:
>+    EnumerationMemberLiteral(Lexer::Token&& origin, EnumerationMember& enumerationMember)
>+        : Expression(WTFMove(origin))
>+        , m_enumerationMember(enumerationMember)
>+    {
>+    }
>+
>+    virtual ~EnumerationMemberLiteral() = default;
> 
>-void resolveNamesInTypes(Program&)
>-{
>+    explicit EnumerationMemberLiteral(const EnumerationMemberLiteral&) = default;
>+    EnumerationMemberLiteral(EnumerationMemberLiteral&&) = default;
>+
>+    bool isEnumerationMemberLiteral() const override { return true; }
>+
>+    EnumerationMember& enumerationMember() { return m_enumerationMember; }
>+
>+private:
>+    EnumerationMember& m_enumerationMember;
>+};
> 
> }
> 
>@@ -47,4 +64,6 @@ void resolveNamesInTypes(Program&)
> 
> }
> 
>+SPECIALIZE_TYPE_TRAITS_WHLSL_EXPRESSION(EnumerationMemberLiteral, isEnumerationMemberLiteral())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLExpression.h
>index e368383646d..a7886fba6b0 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLExpression.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLExpression.h
>@@ -55,7 +55,9 @@ public:
>     virtual bool isCallExpression() const { return false; }
>     virtual bool isCommaExpression() const { return false; }
>     virtual bool isDereferenceExpression() const { return false; }
>+    virtual bool isDotExpression() const { return false; }
>     virtual bool isFloatLiteral() const { return false; }
>+    virtual bool isIndexExpression() const { return false; }
>     virtual bool isIntegerLiteral() const { return false; }
>     virtual bool isLogicalExpression() const { return false; }
>     virtual bool isLogicalNotExpression() const { return false; }
>@@ -67,6 +69,7 @@ public:
>     virtual bool isTernaryExpression() const { return false; }
>     virtual bool isUnsignedIntegerLiteral() const { return false; }
>     virtual bool isVariableReference() const { return false; }
>+    virtual bool isEnumerationMemberLiteral() const { return false; }
> 
> private:
>     Lexer::Token m_origin;
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h
>index 7a7e0a0656c..562af640079 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h
>@@ -30,9 +30,9 @@
> #include "WHLSLFunctionAttribute.h"
> #include "WHLSLLexer.h"
> #include "WHLSLNode.h"
>-#include "WHLSLParameter.h"
> #include "WHLSLSemantic.h"
>-#include "WHLSLType.h"
>+#include "WHLSLUnnamedType.h"
>+#include "WHLSLVariableDeclaration.h"
> #include <wtf/text/WTFString.h>
> 
> namespace WebCore {
>@@ -49,7 +49,7 @@ public:
>         Compute
>     };
> 
>-    FunctionDeclaration(Lexer::Token&& origin, AttributeBlock&& attributeBlock, Optional<EntryPointType> entryPointType, std::unique_ptr<AST::Type>&& type, String&& name, Parameters&& parameters, Optional<AST::Semantic>&& semantic)
>+    FunctionDeclaration(Lexer::Token&& origin, AttributeBlock&& attributeBlock, Optional<EntryPointType> entryPointType, std::unique_ptr<AST::UnnamedType>&& type, String&& name, VariableDeclarations&& parameters, Optional<AST::Semantic>&& semantic)
>         : m_origin(WTFMove(origin))
>         , m_attributeBlock(WTFMove(attributeBlock))
>         , m_entryPointType(entryPointType)
>@@ -65,26 +65,33 @@ public:
>     FunctionDeclaration(const FunctionDeclaration&) = delete;
>     FunctionDeclaration(FunctionDeclaration&&) = default;
> 
>+    virtual bool isFunctionDefinition() const { return false; }
>+    virtual bool isNativeFunctionDeclaration() const { return false; }
>+
>     AttributeBlock& attributeBlock() { return m_attributeBlock; }
>-    AST::Type& type() { return *m_type; }
>-    Parameters& parameters() { return m_parameters; }
>+    const AST::UnnamedType& type() const { return *m_type; }
>+    AST::UnnamedType& type() { return *m_type; }
>+    const String& name() const { return m_name; }
>+    String& name() { return m_name; }
>+    const VariableDeclarations& parameters() const { return m_parameters; }
>+    VariableDeclarations& parameters() { return m_parameters; }
>     Optional<AST::Semantic>& semantic() { return m_semantic; }
> 
>     Lexer::Token&& takeOrigin() { return WTFMove(m_origin); }
>     AttributeBlock&& takeAttributeBlock() { return WTFMove(m_attributeBlock); }
>     Optional<EntryPointType>&& takeEntryPointType() { return WTFMove(m_entryPointType); }
>-    std::unique_ptr<AST::Type>&& takeType() { return WTFMove(m_type); }
>+    std::unique_ptr<AST::UnnamedType>&& takeType() { return WTFMove(m_type); }
>     String&& takeName() { return WTFMove(m_name); }
>-    Parameters&& takeParameters() { return WTFMove(m_parameters); }
>+    VariableDeclarations&& takeParameters() { return WTFMove(m_parameters); }
>     Optional<AST::Semantic>&& takeSemantic() { return WTFMove(m_semantic); }
> 
> private:
>     Lexer::Token m_origin;
>     AttributeBlock m_attributeBlock;
>     Optional<EntryPointType> m_entryPointType;
>-    std::unique_ptr<AST::Type> m_type;
>+    std::unique_ptr<UnnamedType> m_type;
>     String m_name;
>-    Parameters m_parameters;
>+    VariableDeclarations m_parameters;
>     Optional<AST::Semantic> m_semantic;
> };
> 
>@@ -94,4 +101,9 @@ private:
> 
> }
> 
>+#define SPECIALIZE_TYPE_TRAITS_WHLSL_FUNCTION_DECLARATION(ToValueTypeName, predicate) \
>+SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::WHLSL::AST::ToValueTypeName) \
>+    static bool isType(const WebCore::WHLSL::AST::FunctionDeclaration& type) { return type.predicate; } \
>+SPECIALIZE_TYPE_TRAITS_END()
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDefinition.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDefinition.h
>index a4907b0d298..b6b7ba077d3 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDefinition.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDefinition.h
>@@ -50,6 +50,8 @@ public:
>     FunctionDefinition(const FunctionDefinition&) = delete;
>     FunctionDefinition(FunctionDefinition&&) = default;
> 
>+    bool isFunctionDefinition() const override { return true; }
>+
>     Block& block() { return m_block; }
>     bool restricted() const { return m_restricted; }
> 
>@@ -64,4 +66,6 @@ private:
> 
> }
> 
>+SPECIALIZE_TYPE_TRAITS_WHLSL_FUNCTION_DECLARATION(FunctionDefinition, isFunctionDefinition())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLIndexExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLIndexExpression.h
>index 6bb6a0f0dab..43e60a10498 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLIndexExpression.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLIndexExpression.h
>@@ -49,6 +49,25 @@ public:
>     IndexExpression(const IndexExpression&) = delete;
>     IndexExpression(IndexExpression&&) = default;
> 
>+    bool isIndexExpression() const override { return true; }
>+
>+    String getFunctionName() const override
>+    {
>+        return String("operator[]", String::ConstructFromLiteral);
>+    }
>+
>+    String setFunctionName() const override
>+    {
>+        return String("operator&[]", String::ConstructFromLiteral);
>+    }
>+
>+    String andFunctionName() const override
>+    {
>+        return String("operator[]=", String::ConstructFromLiteral);
>+    }
>+
>+    Expression& indexExpression() { return *m_index; }
>+
> private:
>     std::unique_ptr<Expression> m_index;
> };
>@@ -59,4 +78,6 @@ private:
> 
> }
> 
>+SPECIALIZE_TYPE_TRAITS_WHLSL_EXPRESSION(IndexExpression, isIndexExpression())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLParameter.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNamedType.h
>similarity index 61%
>rename from Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLParameter.h
>rename to Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNamedType.h
>index 92586f8691f..2447ec74ee2 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLParameter.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNamedType.h
>@@ -28,11 +28,8 @@
> #if ENABLE(WEBGPU)
> 
> #include "WHLSLLexer.h"
>-#include "WHLSLQualifier.h"
>-#include "WHLSLSemantic.h"
>+#include "WHLSLNode.h"
> #include "WHLSLType.h"
>-#include "WHLSLValue.h"
>-#include <wtf/Vector.h>
> #include <wtf/text/WTFString.h>
> 
> namespace WebCore {
>@@ -41,39 +38,46 @@ namespace WHLSL {
> 
> namespace AST {
> 
>-class Parameter : public Value {
>+class NamedType : public Type {
> public:
>-    Parameter(Lexer::Token&& origin, Qualifiers&& qualifiers, std::unique_ptr<AST::Type>&& type, Optional<String>&& name, Optional<AST::Semantic>&& semantic)
>+    NamedType(Lexer::Token&& origin, String&& name)
>         : m_origin(WTFMove(origin))
>-        , m_qualifiers(WTFMove(qualifiers))
>-        , m_type(WTFMove(type))
>         , m_name(WTFMove(name))
>-        , m_semantic(WTFMove(semantic))
>     {
>     }
> 
>-    virtual ~Parameter() = default;
>+    virtual ~NamedType() = default;
> 
>-    Parameter(const Parameter&) = delete;
>-    Parameter(Parameter&&) = default;
>+    NamedType(const NamedType&) = delete;
>+    NamedType(NamedType&&) = default;
> 
>-    Type& type() { return *m_type; }
>-    Optional<AST::Semantic>& semantic() { return m_semantic; }
>+    Lexer::Token& origin() { return m_origin; }
>+    String& name() { return m_name; }
>+
>+    bool isNamedType() const override { return true; }
>+    virtual bool isTypeDefinition() const { return false; }
>+    virtual bool isStructureDefinition() const { return false; }
>+    virtual bool isEnumerationDefinition() const { return false; }
>+    virtual bool isNativeTypeDeclaration() const { return false; }
>+
>+    virtual const Type& unifyNode() const { return *this; }
> 
> private:
>     Lexer::Token m_origin;
>-    Qualifiers m_qualifiers;
>-    std::unique_ptr<AST::Type> m_type;
>-    Optional<String> m_name;
>-    Optional<AST::Semantic> m_semantic;
>+    String m_name;
> };
> 
>-typedef Vector<Parameter> Parameters;
>-
> }
> 
> }
> 
> }
> 
>+#define SPECIALIZE_TYPE_TRAITS_WHLSL_NAMED_TYPE(ToValueTypeName, predicate) \
>+SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::WHLSL::AST::ToValueTypeName) \
>+    static bool isType(const WebCore::WHLSL::AST::NamedType& type) { return type.predicate; } \
>+SPECIALIZE_TYPE_TRAITS_END()
>+
>+SPECIALIZE_TYPE_TRAITS_WHLSL_TYPE(NamedType, isNamedType())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeFunctionDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeFunctionDeclaration.h
>index 010e6eba700..244e841011c 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeFunctionDeclaration.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeFunctionDeclaration.h
>@@ -37,7 +37,7 @@ namespace AST {
> 
> class NativeFunctionDeclaration : public FunctionDeclaration {
> public:
>-    NativeFunctionDeclaration(Lexer::Token&& origin, AttributeBlock&& attributeBlock, Optional<EntryPointType> entryPointType, std::unique_ptr<AST::Type>&& type, String&& name, Parameters&& parameters, Optional<AST::Semantic>&& semantic, bool restricted)
>+    NativeFunctionDeclaration(Lexer::Token&& origin, AttributeBlock&& attributeBlock, Optional<EntryPointType> entryPointType, std::unique_ptr<AST::UnnamedType>&& type, String&& name, VariableDeclarations&& parameters, Optional<AST::Semantic>&& semantic, bool restricted)
>         : FunctionDeclaration(WTFMove(origin), WTFMove(attributeBlock), WTFMove(entryPointType), WTFMove(type), WTFMove(name), WTFMove(parameters), WTFMove(semantic))
>         , m_restricted(restricted)
>     {
>@@ -48,6 +48,8 @@ public:
>     NativeFunctionDeclaration(const NativeFunctionDeclaration&) = delete;
>     NativeFunctionDeclaration(NativeFunctionDeclaration&&) = default;
> 
>+    bool isNativeFunctionDeclaration() const override { return true; }
>+
>     bool restricted() const { return m_restricted; }
> 
> private:
>@@ -60,4 +62,6 @@ private:
> 
> }
> 
>+SPECIALIZE_TYPE_TRAITS_WHLSL_FUNCTION_DECLARATION(NativeFunctionDeclaration, isNativeFunctionDeclaration())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeTypeDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeTypeDeclaration.h
>index 320abc3c475..6ed98ec7413 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeTypeDeclaration.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeTypeDeclaration.h
>@@ -28,7 +28,7 @@
> #if ENABLE(WEBGPU)
> 
> #include "WHLSLLexer.h"
>-#include "WHLSLType.h"
>+#include "WHLSLNamedType.h"
> #include "WHLSLTypeArgument.h"
> #include <wtf/text/WTFString.h>
> 
>@@ -38,11 +38,10 @@ namespace WHLSL {
> 
> namespace AST {
> 
>-class NativeTypeDeclaration : public Type {
>+class NativeTypeDeclaration : public NamedType {
> public:
>     NativeTypeDeclaration(Lexer::Token&& origin, String&& name, TypeArguments&& typeArguments)
>-        : m_origin(WTFMove(origin))
>-        , m_name(WTFMove(name))
>+        : NamedType(WTFMove(origin), WTFMove(name))
>         , m_typeArguments(WTFMove(typeArguments))
>     {
>     }
>@@ -52,16 +51,13 @@ public:
>     NativeTypeDeclaration(const NativeTypeDeclaration&) = delete;
>     NativeTypeDeclaration(NativeTypeDeclaration&&) = default;
> 
>-    TypeArguments& typeArguments() { return m_typeArguments; }
>+    bool isNativeTypeDeclaration() const override { return true; }
> 
>-    std::unique_ptr<Type> clone() const override
>-    {
>-        ASSERT_NOT_REACHED();
>-        return nullptr;
>-    }
>+    const String& name() const { return m_name; }
>+    String& name() { return m_name; }
>+    TypeArguments& typeArguments() { return m_typeArguments; }
> 
> private:
>-    Lexer::Token m_origin;
>     String m_name;
>     TypeArguments m_typeArguments;
> };
>@@ -72,4 +68,6 @@ private:
> 
> }
> 
>+SPECIALIZE_TYPE_TRAITS_WHLSL_NAMED_TYPE(NativeTypeDeclaration, isNativeTypeDeclaration())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPointerType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPointerType.h
>index 1529426a2ed..63c2093c50e 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPointerType.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPointerType.h
>@@ -39,8 +39,8 @@ namespace AST {
> 
> class PointerType : public ReferenceType {
> public:
>-    PointerType(Lexer::Token&& origin, String&& addressSpace, std::unique_ptr<Type> elementType)
>-        : ReferenceType(WTFMove(origin), WTFMove(addressSpace), WTFMove(elementType))
>+    PointerType(Lexer::Token&& origin, AddressSpace addressSpace, std::unique_ptr<UnnamedType> elementType)
>+        : ReferenceType(WTFMove(origin), addressSpace, WTFMove(elementType))
>     {
>     }
> 
>@@ -49,11 +49,11 @@ public:
>     PointerType(const PointerType&) = delete;
>     PointerType(PointerType&&) = default;
> 
>-    bool isPointerType() const override { return false; }
>+    bool isPointerType() const override { return true; }
> 
>-    std::unique_ptr<Type> clone() const override
>+    std::unique_ptr<UnnamedType> clone() const override
>     {
>-        return std::make_unique<PointerType>(Lexer::Token(origin()), String(addressSpace()), elementType().clone());
>+        return std::make_unique<PointerType>(Lexer::Token(origin()), addressSpace(), elementType().clone());
>     }
> 
> private:
>@@ -65,6 +65,6 @@ private:
> 
> }
> 
>-SPECIALIZE_TYPE_TRAITS_WHLSL_TYPE(PointerType, isPointerType())
>+SPECIALIZE_TYPE_TRAITS_WHLSL_UNNAMED_TYPE(PointerType, isPointerType())
> 
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPropertyAccessExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPropertyAccessExpression.h
>index ba38a5c01ea..d05a72c1fc5 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPropertyAccessExpression.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPropertyAccessExpression.h
>@@ -51,10 +51,30 @@ public:
> 
>     bool isPropertyAccessExpression() const override { return true; }
> 
>+    virtual String getFunctionName() const = 0;
>+    virtual String setFunctionName() const = 0;
>+    virtual String andFunctionName() const = 0;
>+
>+    void setPossibleGetOverloads(const Vector<std::reference_wrapper<FunctionDeclaration>, 1>& overloads)
>+    {
>+        m_possibleGetOverloads = overloads;
>+    }
>+    void setPossibleSetOverloads(const Vector<std::reference_wrapper<FunctionDeclaration>, 1>& overloads)
>+    {
>+        m_possibleSetOverloads = overloads;
>+    }
>+    void setPossibleAndOverloads(const Vector<std::reference_wrapper<FunctionDeclaration>, 1>& overloads)
>+    {
>+        m_possibleAndOverloads = overloads;
>+    }
>+
>     Expression& base() { return *m_base; }
> 
> private:
>     std::unique_ptr<Expression> m_base;
>+    Vector<std::reference_wrapper<FunctionDeclaration>, 1> m_possibleGetOverloads;
>+    Vector<std::reference_wrapper<FunctionDeclaration>, 1> m_possibleSetOverloads;
>+    Vector<std::reference_wrapper<FunctionDeclaration>, 1> m_possibleAndOverloads;
> };
> 
> }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h
>index a4c14ce1cf3..cd556320db0 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h
>@@ -27,7 +27,7 @@
> 
> #if ENABLE(WEBGPU)
> 
>-#include "WHLSLAnonymousVariableDeclaration.h"
>+#include "WHLSLVariableDeclaration.h"
> #include "WHLSLExpression.h"
> #include "WHLSLLexer.h"
> #include "WHLSLVariableReference.h"
>@@ -52,8 +52,8 @@ public:
>     ReadModifyWriteExpression(Lexer::Token&& origin, std::unique_ptr<Expression> lValue)
>         : Expression(Lexer::Token(origin))
>         , m_lValue(WTFMove(lValue))
>-        , m_oldValue(Lexer::Token(origin))
>-        , m_newValue(WTFMove(origin))
>+        , m_oldValue(Lexer::Token(origin), Qualifiers(), nullptr, String(), WTF::nullopt, nullptr)
>+        , m_newValue(WTFMove(origin), Qualifiers(), nullptr, String(), WTF::nullopt, nullptr)
>     {
>     }
> 
>@@ -87,15 +87,15 @@ public:
>     bool isReadModifyWriteExpression() const override { return true; }
> 
>     Expression& lValue() { return *m_lValue; }
>-    AnonymousVariableDeclaration& oldValue() { return m_oldValue; }
>-    AnonymousVariableDeclaration& newValue() { return m_newValue; }
>+    VariableDeclaration& oldValue() { return m_oldValue; }
>+    VariableDeclaration& newValue() { return m_newValue; }
>     Expression& newValueExpression() { return *m_newValueExpression; }
>     Expression& resultExpression() { return *m_resultExpression; }
> 
> private:
>     std::unique_ptr<Expression> m_lValue;
>-    AnonymousVariableDeclaration m_oldValue;
>-    AnonymousVariableDeclaration m_newValue;
>+    VariableDeclaration m_oldValue;
>+    VariableDeclaration m_newValue;
>     std::unique_ptr<Expression> m_newValueExpression;
>     std::unique_ptr<Expression> m_resultExpression;
> };
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReferenceType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReferenceType.h
>index 2257f9be240..4e69f79b8e5 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReferenceType.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReferenceType.h
>@@ -28,7 +28,7 @@
> #if ENABLE(WEBGPU)
> 
> #include "WHLSLLexer.h"
>-#include "WHLSLType.h"
>+#include "WHLSLUnnamedType.h"
> #include <wtf/text/WTFString.h>
> 
> namespace WebCore {
>@@ -37,11 +37,18 @@ namespace WHLSL {
> 
> namespace AST {
> 
>-class ReferenceType : public Type {
>+class ReferenceType : public UnnamedType {
> public:
>-    ReferenceType(Lexer::Token&& origin, String&& addressSpace, std::unique_ptr<Type>&& elementType)
>-        : m_origin(WTFMove(origin))
>-        , m_addressSpace(WTFMove(addressSpace))
>+    enum class AddressSpace {
>+        Constant,
>+        Device,
>+        Threadgroup,
>+        Thread
>+    };
>+
>+    ReferenceType(Lexer::Token&& origin, AddressSpace addressSpace, std::unique_ptr<UnnamedType>&& elementType)
>+        : UnnamedType(WTFMove(origin))
>+        , m_addressSpace(addressSpace)
>         , m_elementType(WTFMove(elementType))
>     {
>     }
>@@ -50,18 +57,16 @@ public:
> 
>     ReferenceType(const ReferenceType&) = delete;
>     ReferenceType(ReferenceType&&) = default;
>-    
>-    Type& elementType() { return *m_elementType; }
> 
>-protected:
>-    const Lexer::Token& origin() const { return m_origin; }
>-    const String& addressSpace() const { return m_addressSpace; }
>-    const Type& elementType() const { return *m_elementType; }
>+    bool isReferenceType() const override { return false; }
>+
>+    AddressSpace addressSpace() const { return m_addressSpace; }
>+    const UnnamedType& elementType() const { return *m_elementType; }
>+    UnnamedType& elementType() { return *m_elementType; }
> 
> private:
>-    Lexer::Token m_origin;
>-    String m_addressSpace;
>-    std::unique_ptr<Type> m_elementType;
>+    AddressSpace m_addressSpace;
>+    std::unique_ptr<UnnamedType> m_elementType;
> };
> 
> }
>@@ -70,4 +75,6 @@ private:
> 
> }
> 
>+SPECIALIZE_TYPE_TRAITS_WHLSL_UNNAMED_TYPE(ReferenceType, isReferenceType())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReturn.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReturn.h
>index c5bfc9e4286..ac9323d2419 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReturn.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReturn.h
>@@ -54,8 +54,11 @@ public:
> 
>     Expression* value() { return m_value.get(); }
> 
>+    void setFunction(FunctionDefinition* functionDefinition) { m_function = functionDefinition; }
>+
> private:
>     std::unique_ptr<Expression> m_value; // nullable
>+    FunctionDefinition* m_function;
> };
> 
> }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureDefinition.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureDefinition.h
>index 87cc62f2356..a8c98e99b4c 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureDefinition.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureDefinition.h
>@@ -29,7 +29,7 @@
> 
> #include "WHLSLLexer.h"
> #include "WHLSLStructureElement.h"
>-#include "WHLSLType.h"
>+#include "WHLSLNamedType.h"
> #include <wtf/Vector.h>
> #include <wtf/text/WTFString.h>
> 
>@@ -39,11 +39,10 @@ namespace WHLSL {
> 
> namespace AST {
> 
>-class StructureDefinition : public Type {
>+class StructureDefinition : public NamedType {
> public:
>     StructureDefinition(Lexer::Token&& origin, String&& name, StructureElements&& structureElements)
>-        : m_origin(WTFMove(origin))
>-        , m_name(WTFMove(name))
>+        : NamedType(WTFMove(origin), WTFMove(name))
>         , m_structureElements(WTFMove(structureElements))
>     {
>     }
>@@ -53,17 +52,11 @@ public:
>     StructureDefinition(const StructureDefinition&) = delete;
>     StructureDefinition(StructureDefinition&&) = default;
> 
>-    StructureElements& structureElements() { return m_structureElements; }
>+    bool isStructureDefinition() const override { return true; }
> 
>-    std::unique_ptr<Type> clone() const override
>-    {
>-        ASSERT_NOT_REACHED();
>-        return nullptr;
>-    }
>+    StructureElements& structureElements() { return m_structureElements; }
> 
> private:
>-    Lexer::Token m_origin;
>-    String m_name;
>     StructureElements m_structureElements;
> };
> 
>@@ -73,4 +66,6 @@ private:
> 
> }
> 
>+SPECIALIZE_TYPE_TRAITS_WHLSL_NAMED_TYPE(StructureDefinition, isStructureDefinition())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h
>index 14be41c7298..a8cbf98df55 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h
>@@ -41,7 +41,7 @@ namespace AST {
> 
> class StructureElement : public Node {
> public:
>-    StructureElement(Lexer::Token&& origin, Qualifiers&& qualifiers, std::unique_ptr<Type>&& type, String&& name, Optional<Semantic> semantic)
>+    StructureElement(Lexer::Token&& origin, Qualifiers&& qualifiers, std::unique_ptr<UnnamedType>&& type, String&& name, Optional<Semantic> semantic)
>         : m_origin(WTFMove(origin))
>         , m_qualifiers(WTFMove(qualifiers))
>         , m_type(WTFMove(type))
>@@ -55,13 +55,15 @@ public:
>     StructureElement(const StructureElement&) = delete;
>     StructureElement(StructureElement&&) = default;
> 
>-    Type& type() { return *m_type; }
>+    Lexer::Token& origin() { return m_origin; }
>+    UnnamedType& type() { return *m_type; }
>+    const String& name() { return m_name; }
>     Optional<Semantic>& semantic() { return m_semantic; }
> 
> private:
>     Lexer::Token m_origin;
>     Qualifiers m_qualifiers;
>-    std::unique_ptr<Type> m_type;
>+    std::unique_ptr<UnnamedType> m_type;
>     String m_name;
>     Optional<Semantic> m_semantic;
> };
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLType.h
>index cf4cbc88790..573a8bb68c7 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLType.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLType.h
>@@ -45,12 +45,8 @@ public:
>     Type(const Type&) = delete;
>     Type(Type&&) = default;
> 
>-    virtual bool isTypeReference() const { return false; }
>-    virtual bool isPointerType() const { return false; }
>-    virtual bool isArrayReferenceType() const { return false; }
>-    virtual bool isArrayType() const { return false; }
>-
>-    virtual std::unique_ptr<Type> clone() const = 0;
>+    virtual bool isNamedType() const { return false; }
>+    virtual bool isUnnamedType() const { return false; }
> 
> private:
> };
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLTypeDefinition.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLTypeDefinition.h
>index f73629e29b1..69aa23a1fa4 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLTypeDefinition.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLTypeDefinition.h
>@@ -29,7 +29,8 @@
> 
> #include "WHLSLLexer.h"
> #include "WHLSLNode.h"
>-#include "WHLSLType.h"
>+#include "WHLSLNamedType.h"
>+#include "WHLSLUnnamedType.h"
> #include <wtf/text/WTFString.h>
> 
> namespace WebCore {
>@@ -38,11 +39,10 @@ namespace WHLSL {
> 
> namespace AST {
> 
>-class TypeDefinition : public Type {
>+class TypeDefinition : public NamedType {
> public:
>-    TypeDefinition(Lexer::Token&& origin, String&& name, std::unique_ptr<AST::Type>&& type)
>-        : m_origin(WTFMove(origin))
>-        , m_name(WTFMove(name))
>+    TypeDefinition(Lexer::Token&& origin, String&& name, std::unique_ptr<AST::UnnamedType>&& type)
>+        : NamedType(WTFMove(origin), WTFMove(name))
>         , m_type(WTFMove(type))
>     {
>     }
>@@ -52,18 +52,18 @@ public:
>     TypeDefinition(const TypeDefinition&) = delete;
>     TypeDefinition(TypeDefinition&&) = default;
> 
>-    AST::Type& type() { return *m_type; }
>+    bool isTypeDefinition() const override { return true; }
> 
>-    std::unique_ptr<Type> clone() const override
>+    AST::UnnamedType& type() { return *m_type; }
>+
>+    const Type& unifyNode() const override
>     {
>-        ASSERT_NOT_REACHED();
>-        return nullptr;
>+        ASSERT(m_type);
>+        return m_type->unifyNode();
>     }
> 
> private:
>-    Lexer::Token m_origin;
>-    String m_name;
>-    std::unique_ptr<AST::Type> m_type;
>+    std::unique_ptr<AST::UnnamedType> m_type;
> };
> 
> }
>@@ -72,4 +72,6 @@ private:
> 
> }
> 
>+SPECIALIZE_TYPE_TRAITS_WHLSL_NAMED_TYPE(TypeDefinition, isTypeDefinition())
>+
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLTypeReference.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLTypeReference.h
>index 49441d8b5c7..9293aa264e8 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLTypeReference.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLTypeReference.h
>@@ -28,8 +28,9 @@
> #if ENABLE(WEBGPU)
> 
> #include "WHLSLLexer.h"
>-#include "WHLSLType.h"
>+#include "WHLSLNativeTypeDeclaration.h"
> #include "WHLSLTypeArgument.h"
>+#include "WHLSLUnnamedType.h"
> #include <wtf/text/WTFString.h>
> 
> namespace WebCore {
>@@ -38,10 +39,10 @@ namespace WHLSL {
> 
> namespace AST {
> 
>-class TypeReference : public Type {
>+class TypeReference : public UnnamedType {
> public:
>     TypeReference(Lexer::Token&& origin, String&& name, TypeArguments&& typeArguments)
>-        : m_origin(WTFMove(origin))
>+        : UnnamedType(WTFMove(origin))
>         , m_name(WTFMove(name))
>         , m_typeArguments(WTFMove(typeArguments))
>     {
>@@ -52,24 +53,47 @@ public:
>     TypeReference(const TypeReference&) = delete;
>     TypeReference(TypeReference&&) = default;
> 
>+    static std::unique_ptr<TypeReference> wrap(Lexer::Token&& origin, NamedType& resolvedType)
>+    {
>+        TypeArguments typeArguments;
>+        if (is<NativeTypeDeclaration>(resolvedType))
>+            typeArguments = AST::clone(downcast<NativeTypeDeclaration>(resolvedType).typeArguments());
>+        auto result = std::make_unique<TypeReference>(WTFMove(origin), String(resolvedType.name()), WTFMove(typeArguments));
>+        result->setResolvedType(resolvedType);
>+        return result;
>+    }
>+
>     bool isTypeReference() const override { return true; }
> 
>+    String& name() { return m_name; }
>     TypeArguments& typeArguments() { return m_typeArguments; }
>+    NamedType* resolvedType() { return m_resolvedType; }
>+
>+    const Type& unifyNode() const override
>+    {
>+        ASSERT(m_resolvedType);
>+        return m_resolvedType->unifyNode();
>+    }
>+    
>+    void setResolvedType(NamedType& resolvedType)
>+    {
>+        m_resolvedType = &resolvedType;
>+    }
> 
>     std::unique_ptr<TypeReference> cloneTypeReference() const
>     {
>-        return std::make_unique<TypeReference>(Lexer::Token(m_origin), String(m_name), AST::clone(m_typeArguments));
>+        return std::make_unique<TypeReference>(Lexer::Token(origin()), String(m_name), AST::clone(m_typeArguments));
>     }
> 
>-    std::unique_ptr<Type> clone() const override
>+    std::unique_ptr<UnnamedType> clone() const override
>     {
>         return cloneTypeReference();
>     }
> 
> private:
>-    Lexer::Token m_origin;
>     String m_name;
>     TypeArguments m_typeArguments;
>+    NamedType* m_resolvedType { nullptr };
> };
> 
> }
>@@ -78,6 +102,6 @@ private:
> 
> }
> 
>-SPECIALIZE_TYPE_TRAITS_WHLSL_TYPE(TypeReference, isTypeReference())
>+SPECIALIZE_TYPE_TRAITS_WHLSL_UNNAMED_TYPE(TypeReference, isTypeReference())
> 
> #endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLUnnamedType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLUnnamedType.h
>new file mode 100644
>index 00000000000..73a8f0a0c46
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLUnnamedType.h
>@@ -0,0 +1,83 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLLexer.h"
>+#include "WHLSLNode.h"
>+#include "WHLSLType.h"
>+#include <wtf/text/WTFString.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+namespace AST {
>+
>+class UnnamedType : public Type {
>+public:
>+    UnnamedType(Lexer::Token&& origin)
>+        : m_origin(WTFMove(origin))
>+    {
>+    }
>+
>+    virtual ~UnnamedType() = default;
>+
>+    UnnamedType(const UnnamedType&) = delete;
>+    UnnamedType(UnnamedType&&) = default;
>+
>+    bool isUnnamedType() const override { return true; }
>+    virtual bool isTypeReference() const { return false; }
>+    virtual bool isPointerType() const { return false; }
>+    virtual bool isArrayReferenceType() const { return false; }
>+    virtual bool isArrayType() const { return false; }
>+    virtual bool isReferenceType() const { return false; }
>+
>+    virtual const Type& unifyNode() const { return *this; }
>+
>+    virtual std::unique_ptr<UnnamedType> clone() const = 0;
>+
>+    const Lexer::Token& origin() const { return m_origin; }
>+
>+private:
>+    Lexer::Token m_origin;
>+};
>+
>+}
>+
>+}
>+
>+}
>+
>+#define SPECIALIZE_TYPE_TRAITS_WHLSL_UNNAMED_TYPE(ToValueTypeName, predicate) \
>+SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::WHLSL::AST::ToValueTypeName) \
>+    static bool isType(const WebCore::WHLSL::AST::UnnamedType& type) { return type.predicate; } \
>+SPECIALIZE_TYPE_TRAITS_END()
>+
>+SPECIALIZE_TYPE_TRAITS_WHLSL_TYPE(UnnamedType, isUnnamedType())
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h
>index ff0368193bd..8520cadcc35 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h
>@@ -44,7 +44,7 @@ namespace AST {
> 
> class VariableDeclaration : public Value {
> public:
>-    VariableDeclaration(Lexer::Token&& origin, Qualifiers&& qualifiers, std::unique_ptr<AST::Type>&& type, String&& name, Optional<Semantic>&& semantic, std::unique_ptr<Expression>&& initializer)
>+    VariableDeclaration(Lexer::Token&& origin, Qualifiers&& qualifiers, std::unique_ptr<AST::UnnamedType>&& type, String&& name, Optional<Semantic>&& semantic, std::unique_ptr<Expression>&& initializer)
>         : m_origin(WTFMove(origin))
>         , m_qualifiers(WTFMove(qualifiers))
>         , m_type(WTFMove(type))
>@@ -60,20 +60,23 @@ public:
>     VariableDeclaration(VariableDeclaration&&) = default;
> 
>     Lexer::Token origin() const { return m_origin; }
>+    String& name() { return m_name; }
> 
>-    Type& type() { return *m_type; }
>+    UnnamedType& type() { return *m_type; }
>     Optional<Semantic>& semantic() { return m_semantic; }
>     Expression* initializer() { return m_initializer.get(); }
> 
> private:
>     Lexer::Token m_origin;
>     Qualifiers m_qualifiers;
>-    std::unique_ptr<AST::Type> m_type;
>+    std::unique_ptr<AST::UnnamedType> m_type;
>     String m_name;
>     Optional<Semantic> m_semantic;
>     std::unique_ptr<Expression> m_initializer;
> };
> 
>+typedef Vector<VariableDeclaration> VariableDeclarations;
>+
> }
> 
> }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableReference.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableReference.h
>index 2ae828d5295..e39ecf5c59f 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableReference.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableReference.h
>@@ -27,7 +27,7 @@
> 
> #if ENABLE(WEBGPU)
> 
>-#include "WHLSLAnonymousVariableDeclaration.h"
>+#include "WHLSLVariableDeclaration.h"
> #include "WHLSLExpression.h"
> #include "WHLSLLexer.h"
> #include "WHLSLVariableDeclaration.h"
>@@ -55,19 +55,21 @@ public:
>     static VariableReference wrap(VariableDeclaration& variableDeclaration)
>     {
>         VariableReference result(Lexer::Token(variableDeclaration.origin()));
>-        result.m_variable = { &variableDeclaration };
>+        result.m_variable = &variableDeclaration;
>         return result;
>     }
> 
>-    static VariableReference wrap(AnonymousVariableDeclaration& anonymousVariableDeclaration)
>+    bool isVariableReference() const override { return true; }
>+
>+    String& name() { return m_name; }
>+
>+    VariableDeclaration* variable() { return m_variable; }
>+
>+    void setVariable(VariableDeclaration& variableDeclaration)
>     {
>-        VariableReference result(Lexer::Token(anonymousVariableDeclaration.origin()));
>-        result.m_variable = { &anonymousVariableDeclaration };
>-        return result;
>+        m_variable = &variableDeclaration;
>     }
> 
>-    bool isVariableReference() const override { return true; }
>-
> private:
>     VariableReference(Lexer::Token&& origin)
>         : Expression(WTFMove(origin))
>@@ -75,7 +77,7 @@ private:
>     }
> 
>     String m_name;
>-    Optional<Variant<VariableDeclaration*, AnonymousVariableDeclaration*>> m_variable;
>+    VariableDeclaration* m_variable;
> };
> 
> }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckDuplicateFunctions.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckDuplicateFunctions.h
>new file mode 100644
>index 00000000000..3c32f4cfcf4
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckDuplicateFunctions.h
>@@ -0,0 +1,121 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLInferTypes.h"
>+#include "WHLSLProgram.h"
>+#include <algorithm>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+inline bool checkDuplicateFunctions(const Program& program)
>+{
>+    Vector<std::reference_wrapper<AST::FunctionDeclaration>> functions;
>+    for (auto& functionDefinition : program.functionDefinitions())
>+        functions.append(*functionDefinition);
>+    for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations())
>+        functions.append(*nativeFunctionDeclaration);
>+
>+    std::sort(functions.begin(), functions.end(), [](const AST::FunctionDeclaration& a, const AST::FunctionDeclaration& b) -> bool {
>+        for (unsigned i = 0; i < std::min(a.name().length(), b.name().length()); ++i) {
>+            if (a.name()[i] < b.name()[i])
>+                return true;
>+            if (a.name()[i] > b.name()[i])
>+                return false;
>+        }
>+        return a.name().length() < b.name().length();
>+    });
>+    for (size_t i = 0; i < functions.size(); ++i) {
>+        for (size_t j = i + 1; j < functions.size(); ++i) {
>+            if (functions[i].get().name() != functions[j].get().name())
>+                break;
>+            if (is<AST::NativeFunctionDeclaration>(functions[i].get()) && is<AST::NativeFunctionDeclaration>(functions[j].get()))
>+                continue;
>+            if (functions[i].get().parameters().size() != functions[j].get().parameters().size())
>+                continue;
>+            if (functions[i].get().name() == "operator cast") {
>+                bool same = true;
>+                if (!matches(functions[i].get().type(), functions[j].get().type()))
>+                    same = false;
>+                else {
>+                    for (size_t k = 0; k < functions[i].get().parameters().size(); ++k) {
>+                        if (!matches(functions[i].get().parameters()[k].type(), functions[j].get().parameters()[k].type())) {
>+                            same = false;
>+                            break;
>+                        }
>+                    }
>+                }
>+                if (same)
>+                    return false;
>+            } else {
>+                bool same = true;
>+                for (size_t k = 0; k < functions[i].get().parameters().size(); ++k) {
>+                    if (!matches(functions[i].get().parameters()[k].type(), functions[j].get().parameters()[k].type())) {
>+                        same = false;
>+                        break;
>+                    }
>+                }
>+                if (same)
>+                    return false;
>+            }
>+        }
>+        
>+        if (functions[i].get().name() == "operator&[]" && functions[i].get().parameters().size() == 2
>+            && is<AST::ArrayReferenceType>(functions[i].get().parameters()[0].type())) {
>+            auto& type = functions[i].get().parameters()[1].type();
>+            if (is<AST::TypeReference>(type)) {
>+                if (auto* resolvedType = downcast<AST::TypeReference>(type).resolvedType()) {
>+                    if (is<AST::NativeTypeDeclaration>(*resolvedType)) {
>+                        auto& nativeTypeDeclaration = downcast<AST::NativeTypeDeclaration>(*resolvedType);
>+                        if (nativeTypeDeclaration.name() == "uint")
>+                            return false;
>+                    }
>+                }
>+            }
>+        } else if (functions[i].get().name() == "operator.length" && functions[i].get().parameters().size() == 1
>+            && (is<AST::ArrayReferenceType>(functions[i].get().parameters()[0].type())
>+            || is<AST::ArrayType>(functions[i].get().parameters()[0].type())))
>+            return false;
>+        else if (functions[i].get().name() == "operator=="
>+            && functions[i].get().parameters().size() == 2
>+            && is<AST::ReferenceType>(functions[i].get().parameters()[0].type())
>+            && is<AST::ReferenceType>(functions[i].get().parameters()[1].type())
>+            && matches(functions[i].get().parameters()[0].type(), functions[i].get().parameters()[1].type()))
>+            return false;
>+    }
>+    return true;
>+}
>+
>+}
>+
>+}
>+
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.h
>new file mode 100644
>index 00000000000..db13dd0a63f
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.h
>@@ -0,0 +1,132 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLTypeDefinition.h"
>+#include "WHLSLStructureDefinition.h"
>+#include "WHLSLEnumerationDefinition.h"
>+#include "WHLSLNamedType.h"
>+#include "WHLSLNativeTypeDeclaration.h"
>+#include "WHLSLTypeArgument.h"
>+#include <wtf/Variant.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+inline bool matches(const AST::UnnamedType& unnamedType, const AST::UnnamedType& other)
>+{
>+    auto& unifyThis = unnamedType.unifyNode();
>+    auto& unifyOther = other.unifyNode();
>+
>+    if (&unifyThis == &unifyOther)
>+        return true;
>+
>+    if (is<AST::NamedType>(unifyThis) && is<AST::NamedType>(unifyOther)) {
>+#if !ASSERT_DISABLED
>+        auto& namedThis = downcast<AST::NamedType>(unifyThis);
>+        auto& namedOther = downcast<AST::NamedType>(unifyOther);
>+        ASSERT(!is<AST::TypeDefinition>(namedThis) && !is<AST::TypeDefinition>(namedOther));
>+#endif
>+        return false;
>+    } else if (is<AST::UnnamedType>(unifyThis) && is<AST::UnnamedType>(unifyOther)) {
>+        auto& unnamedThis = downcast<AST::UnnamedType>(unifyThis);
>+        auto& unnamedOther = downcast<AST::UnnamedType>(unifyOther);
>+        ASSERT(!is<AST::TypeReference>(unnamedThis) && !is<AST::TypeReference>(unnamedOther));
>+        if (is<AST::PointerType>(unnamedThis) && is<AST::PointerType>(unnamedOther)) {
>+            auto& pointerThis = downcast<AST::PointerType>(unnamedThis);
>+            auto& pointerOther = downcast<AST::PointerType>(unnamedOther);
>+            if (pointerThis.addressSpace() != pointerOther.addressSpace())
>+                return false;
>+            return matches(pointerThis.elementType(), pointerOther.elementType());
>+        }
>+        if (is<AST::ArrayReferenceType>(unnamedThis) && is<AST::ArrayReferenceType>(unnamedOther)){
>+            auto& arrayReferenceThis = downcast<AST::ArrayReferenceType>(unnamedThis);
>+            auto& arrayReferenceOther = downcast<AST::ArrayReferenceType>(unnamedOther);
>+            if (arrayReferenceThis.addressSpace() != arrayReferenceOther.addressSpace())
>+                return false;
>+            return matches(arrayReferenceThis.elementType(), arrayReferenceOther.elementType());
>+        }
>+        if (is<AST::ArrayType>(unnamedThis) && is<AST::ArrayType>(unnamedOther)) {
>+            auto& arrayThis = downcast<AST::ArrayType>(unnamedThis);
>+            auto& arrayOther = downcast<AST::ArrayType>(unnamedOther);
>+            if (arrayThis.numElements() != arrayOther.numElements())
>+                return false;
>+            return matches(arrayThis.type(), arrayOther.type());
>+        }
>+        return false;
>+    }
>+    return false;
>+}
>+
>+inline bool inferTypesForTypeArguments(AST::NamedType& possibleType, AST::TypeArguments& typeArguments)
>+{
>+    if (is<AST::TypeDefinition>(possibleType)
>+        || is<AST::StructureDefinition>(possibleType)
>+        || is<AST::EnumerationDefinition>(possibleType)) {
>+        return typeArguments.isEmpty();
>+    }
>+
>+    ASSERT(is<AST::NativeTypeDeclaration>(possibleType));
>+    auto& nativeTypeDeclaration = downcast<AST::NativeTypeDeclaration>(possibleType);
>+    if (nativeTypeDeclaration.typeArguments().size() != typeArguments.size())
>+        return false;
>+    for (size_t i = 0; i < nativeTypeDeclaration.typeArguments().size(); ++i) {
>+        AST::ConstantExpression* typeArgumentExpression = nullptr;
>+        AST::TypeReference* typeArgumentTypeReference = nullptr;
>+        AST::ConstantExpression* nativeTypeArgumentExpression = nullptr;
>+        AST::TypeReference* nativeTypeArgumentTypeReference = nullptr;
>+
>+        auto assign = [&](AST::TypeArgument& typeArgument, AST::ConstantExpression*& expression, AST::TypeReference*& typeReference) {
>+            WTF::visit(WTF::makeVisitor([&](AST::ConstantExpression& constantExpression) {
>+                expression = &constantExpression;
>+            }, [&](std::unique_ptr<AST::TypeReference>& theTypeReference) {
>+                typeReference = theTypeReference.get();
>+            }), typeArgument);
>+        };
>+
>+        assign(typeArguments[i], typeArgumentExpression, typeArgumentTypeReference);
>+        assign(nativeTypeDeclaration.typeArguments()[i], nativeTypeArgumentExpression, nativeTypeArgumentTypeReference);
>+
>+        if (typeArgumentExpression && nativeTypeArgumentExpression) {
>+            if (!typeArgumentExpression->matches(*nativeTypeArgumentExpression))
>+                return false;
>+        } else if (typeArgumentTypeReference && nativeTypeArgumentTypeReference) {
>+            if (!matches(*typeArgumentTypeReference, *nativeTypeArgumentTypeReference))
>+                return false;
>+        }
>+    }
>+
>+    return true;
>+}
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.cpp
>new file mode 100644
>index 00000000000..83222725440
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.cpp
>@@ -0,0 +1,254 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "config.h"
>+#include "WHLSLIntrinsics.h"
>+
>+#include "WHLSLConstantExpression.h"
>+#include "WHLSLTypeArgument.h"
>+#include "WHLSLTypeReference.h"
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+Intrinsics::Intrinsics()
>+    : textureTypeNames { String("Texture1D", String::ConstructFromLiteral),
>+            String("RWTexture1D", String::ConstructFromLiteral),
>+            String("Texture1DArray", String::ConstructFromLiteral),
>+            String("RWTexture1DArray", String::ConstructFromLiteral),
>+            String("Texture2D", String::ConstructFromLiteral),
>+            String("RWTexture2D", String::ConstructFromLiteral),
>+            String("Texture2DArray", String::ConstructFromLiteral),
>+            String("RWTexture2DArray", String::ConstructFromLiteral),
>+            String("Texture3D", String::ConstructFromLiteral),
>+            String("RWTexture3D", String::ConstructFromLiteral),
>+            String("TextureCube",  String::ConstructFromLiteral) }
>+    , textureInnerTypeNames { String("uchar", String::ConstructFromLiteral),
>+            String("ushort", String::ConstructFromLiteral),
>+            String("uint", String::ConstructFromLiteral),
>+            String("char", String::ConstructFromLiteral),
>+            String("short", String::ConstructFromLiteral),
>+            String("int", String::ConstructFromLiteral),
>+            String("half", String::ConstructFromLiteral),
>+            String("float", String::ConstructFromLiteral) }
>+    , depthTextureInnerTypes { String("half", String::ConstructFromLiteral),
>+            String("float", String::ConstructFromLiteral) }
>+{
>+    ASSERT(textureTypeNames.size() == 11); // fullTextures hardcodes the length of this array.
>+    ASSERT(textureInnerTypeNames.size() == 8); // fullTextures hardcodes the length of this array.
>+    ASSERT(depthTextureInnerTypes.size() == 2); // textureDepth2D & friends hardcodes the length of this array.
>+}
>+
>+bool Intrinsics::addPrimitive(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    if (nativeTypeDeclaration.typeArguments().size() != 0)
>+        return false;
>+
>+    if (nativeTypeDeclaration.name() == "void")
>+        voidType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "bool")
>+        boolType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "uchar")
>+        ucharType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "ushort")
>+        ushortType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "uint")
>+        uintType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "char")
>+        charType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "short")
>+        shortType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "int")
>+        intType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "half")
>+        halfType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "float")
>+        floatType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "atomic_int")
>+        atomicIntType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "atomic_uint")
>+        atomicUintType = &nativeTypeDeclaration;
>+    else if (nativeTypeDeclaration.name() == "sampler")
>+        samplerType = &nativeTypeDeclaration;
>+    else
>+        ASSERT_NOT_REACHED();
>+    return true;
>+}
>+
>+bool Intrinsics::addVector(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    if (nativeTypeDeclaration.name() != "vector")
>+        return false;
>+
>+    ASSERT(nativeTypeDeclaration.typeArguments().size() == 2);
>+    ASSERT(WTF::holds_alternative<std::unique_ptr<AST::TypeReference>>(nativeTypeDeclaration.typeArguments()[0]));
>+    ASSERT(WTF::holds_alternative<AST::ConstantExpression>(nativeTypeDeclaration.typeArguments()[1]));
>+    auto& innerTypePointer = WTF::get<std::unique_ptr<AST::TypeReference>>(nativeTypeDeclaration.typeArguments()[0]);
>+    auto& lengthExpression = WTF::get<AST::ConstantExpression>(nativeTypeDeclaration.typeArguments()[1]);
>+    ASSERT(innerTypePointer);
>+    auto& innerType = *innerTypePointer;
>+    ASSERT(innerType.typeArguments().size() == 0);
>+    AST::NativeTypeDeclaration** array;
>+    if (innerType.name() == "bool")
>+        array = vectorBool;
>+    else if (innerType.name() == "uchar")
>+        array = vectorUchar;
>+    else if (innerType.name() == "ushort")
>+        array = vectorUshort;
>+    else if (innerType.name() == "uint")
>+        array = vectorUint;
>+    else if (innerType.name() == "char")
>+        array = vectorChar;
>+    else if (innerType.name() == "short")
>+        array = vectorShort;
>+    else if (innerType.name() == "int")
>+        array = vectorInt;
>+    else if (innerType.name() == "half")
>+        array = vectorHalf;
>+    else if (innerType.name() == "float")
>+        array = vectorFloat;
>+    else
>+        ASSERT_NOT_REACHED();
>+    int length = lengthExpression.integerLiteral().value();
>+    ASSERT(length >= 2 && length <= 4);
>+    array[length - 2] = &nativeTypeDeclaration;
>+    return true;
>+}
>+
>+bool Intrinsics::addMatrix(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    if (nativeTypeDeclaration.name() != "matrix")
>+        return false;
>+
>+    ASSERT(nativeTypeDeclaration.typeArguments().size() == 3);
>+    ASSERT(WTF::holds_alternative<std::unique_ptr<AST::TypeReference>>(nativeTypeDeclaration.typeArguments()[0]));
>+    ASSERT(WTF::holds_alternative<AST::ConstantExpression>(nativeTypeDeclaration.typeArguments()[1]));
>+    ASSERT(WTF::holds_alternative<AST::ConstantExpression>(nativeTypeDeclaration.typeArguments()[2]));
>+    auto& innerTypePointer = WTF::get<std::unique_ptr<AST::TypeReference>>(nativeTypeDeclaration.typeArguments()[0]);
>+    auto& rowExpression = WTF::get<AST::ConstantExpression>(nativeTypeDeclaration.typeArguments()[1]);
>+    auto& columnExpression = WTF::get<AST::ConstantExpression>(nativeTypeDeclaration.typeArguments()[2]);
>+    ASSERT(innerTypePointer);
>+    auto& innerType = *innerTypePointer;
>+    ASSERT(innerType.typeArguments().size() == 0);
>+    AST::NativeTypeDeclaration* (*array)[3];
>+    if (innerType.name() == "half")
>+        array = matrixHalf;
>+    if (innerType.name() == "float")
>+        array = matrixFloat;
>+    int row = rowExpression.integerLiteral().value();
>+    ASSERT(row >= 2 && row <= 4);
>+    int column = columnExpression.integerLiteral().value();
>+    ASSERT(column >= 2 && column <= 4);
>+    array[row - 2][column - 2] = &nativeTypeDeclaration;
>+    return true;
>+}
>+
>+bool Intrinsics::addFullTexture(AST::NativeTypeDeclaration& nativeTypeDeclaration, AST::TypeReference& innerType)
>+{
>+    unsigned textureTypeIndex = textureTypeNames.size();
>+    for (unsigned i = 0; i < textureTypeNames.size(); ++i) {
>+        if (nativeTypeDeclaration.name() == textureTypeNames[i])
>+            textureTypeIndex = i;
>+    }
>+    if (textureTypeIndex == textureTypeNames.size())
>+        return false;
>+
>+    unsigned innerTypeIndex = textureInnerTypeNames.size();
>+    unsigned vectorLength;
>+    for (unsigned i = 0; i < textureInnerTypeNames.size(); ++i) {
>+        if (innerType.name().startsWith(textureInnerTypeNames[i])) {
>+            textureTypeIndex = i;
>+            if (innerType.name() == textureInnerTypeNames[i])
>+                vectorLength = 1;
>+            else {
>+                ASSERT(innerType.name().length() == textureInnerTypeNames[i].length() + 1);
>+                ASSERT(innerType.name()[innerType.name().length() - 1] == '2'
>+                    || innerType.name()[innerType.name().length() - 1] == '3'
>+                    || innerType.name()[innerType.name().length() - 1] == '4');
>+                vectorLength = innerType.name()[innerType.name().length() - 1] - '0';
>+            }
>+        }
>+    }
>+    ASSERT(innerTypeIndex != textureInnerTypeNames.size());
>+    fullTextures[textureTypeIndex][innerTypeIndex][vectorLength - 1] = &nativeTypeDeclaration;
>+    return true;
>+}
>+
>+void Intrinsics::addDepthTexture(AST::NativeTypeDeclaration& nativeTypeDeclaration, AST::TypeReference& innerType)
>+{
>+    AST::NativeTypeDeclaration** texture;
>+    if (nativeTypeDeclaration.name() == "TextureDepth2D")
>+        texture = textureDepth2D;
>+    else if (nativeTypeDeclaration.name() == "RWTextureDepth2D")
>+        texture = rwTextureDepth2D;
>+    else if (nativeTypeDeclaration.name() == "TextureDepth2DArray")
>+        texture = textureDepth2DArray;
>+    else if (nativeTypeDeclaration.name() == "RWTextureDepth2DArray")
>+        texture = rwTextureDepth2DArray;
>+    else if (nativeTypeDeclaration.name() == "TextureDepthCube")
>+        texture = textureDepthCube;
>+    else
>+        ASSERT_NOT_REACHED();
>+    unsigned innerTypeIndex = depthTextureInnerTypes.size();
>+    for (unsigned i = 0; i < depthTextureInnerTypes.size(); ++i) {
>+        if (innerType.name() == depthTextureInnerTypes[i])
>+            innerTypeIndex = i;
>+    }
>+    ASSERT(innerTypeIndex != depthTextureInnerTypes.size());
>+    texture[innerTypeIndex] = &nativeTypeDeclaration;
>+}
>+
>+void Intrinsics::addTexture(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    ASSERT(nativeTypeDeclaration.typeArguments().size() == 1);
>+    ASSERT(WTF::holds_alternative<std::unique_ptr<AST::TypeReference>>(nativeTypeDeclaration.typeArguments()[0]));
>+    auto& innerTypePointer = WTF::get<std::unique_ptr<AST::TypeReference>>(nativeTypeDeclaration.typeArguments()[0]);
>+    ASSERT(innerTypePointer);
>+    auto& innerType = *innerTypePointer;
>+    ASSERT(innerType.typeArguments().size() == 0);
>+    if (addFullTexture(nativeTypeDeclaration, innerType))
>+        return;
>+    addDepthTexture(nativeTypeDeclaration, innerType);
>+}
>+
>+void Intrinsics::add(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    if (addPrimitive(nativeTypeDeclaration))
>+        return;
>+    if (addVector(nativeTypeDeclaration))
>+        return;
>+    if (addMatrix(nativeTypeDeclaration))
>+        return;
>+    addTexture(nativeTypeDeclaration);
>+}
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.h
>new file mode 100644
>index 00000000000..55b8f2a3f6a
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.h
>@@ -0,0 +1,106 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLNativeFunctionDeclaration.h"
>+#include "WHLSLNativeTypeDeclaration.h"
>+#include <cstring>
>+#include <wtf/StdLibExtras.h>
>+#include <wtf/Vector.h>
>+#include <wtf/text/WTFString.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+class Intrinsics {
>+public:
>+    Intrinsics();
>+
>+    void add(AST::NativeFunctionDeclaration& nativeFunctionDeclaration)
>+    {
>+        if (nativeFunctionDeclaration.name() == "asdf") {
>+        
>+        }
>+    }
>+
>+    void add(AST::NativeTypeDeclaration&);
>+
>+private:
>+    bool addPrimitive(AST::NativeTypeDeclaration&);
>+    bool addVector(AST::NativeTypeDeclaration&);
>+    bool addMatrix(AST::NativeTypeDeclaration&);
>+    bool addFullTexture(AST::NativeTypeDeclaration&, AST::TypeReference&);
>+    void addDepthTexture(AST::NativeTypeDeclaration&, AST::TypeReference&);
>+    void addTexture(AST::NativeTypeDeclaration&);
>+
>+    AST::NativeTypeDeclaration* voidType;
>+    AST::NativeTypeDeclaration* boolType;
>+    AST::NativeTypeDeclaration* ucharType;
>+    AST::NativeTypeDeclaration* ushortType;
>+    AST::NativeTypeDeclaration* uintType;
>+    AST::NativeTypeDeclaration* charType;
>+    AST::NativeTypeDeclaration* shortType;
>+    AST::NativeTypeDeclaration* intType;
>+    AST::NativeTypeDeclaration* halfType;
>+    AST::NativeTypeDeclaration* floatType;
>+    AST::NativeTypeDeclaration* atomicIntType;
>+    AST::NativeTypeDeclaration* atomicUintType;
>+    AST::NativeTypeDeclaration* samplerType;
>+
>+    AST::NativeTypeDeclaration* vectorBool[3];
>+    AST::NativeTypeDeclaration* vectorUchar[3];
>+    AST::NativeTypeDeclaration* vectorUshort[3];
>+    AST::NativeTypeDeclaration* vectorUint[3];
>+    AST::NativeTypeDeclaration* vectorChar[3];
>+    AST::NativeTypeDeclaration* vectorShort[3];
>+    AST::NativeTypeDeclaration* vectorInt[3];
>+    AST::NativeTypeDeclaration* vectorHalf[3];
>+    AST::NativeTypeDeclaration* vectorFloat[3];
>+
>+    AST::NativeTypeDeclaration* matrixHalf[3][3];
>+    AST::NativeTypeDeclaration* matrixFloat[3][3];
>+
>+    Vector<String> textureTypeNames;
>+    Vector<String> textureInnerTypeNames;
>+
>+    AST::NativeTypeDeclaration* fullTextures[11][8][4];
>+
>+    Vector<String> depthTextureInnerTypes;
>+    AST::NativeTypeDeclaration* textureDepth2D[2];
>+    AST::NativeTypeDeclaration* rwTextureDepth2D[2];
>+    AST::NativeTypeDeclaration* textureDepth2DArray[2];
>+    AST::NativeTypeDeclaration* rwTextureDepth2DArray[2];
>+    AST::NativeTypeDeclaration* textureDepthCube[2];
>+};
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameContext.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameContext.h
>new file mode 100644
>index 00000000000..cb703788008
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameContext.h
>@@ -0,0 +1,176 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLTypeDefinition.h"
>+#include "WHLSLStructureDefinition.h"
>+#include "WHLSLEnumerationDefinition.h"
>+#include "WHLSLFunctionDefinition.h"
>+#include "WHLSLNativeFunctionDeclaration.h"
>+#include "WHLSLNativeTypeDeclaration.h"
>+#include "WHLSLVariableDeclaration.h"
>+#include <functional>
>+#include <wtf/HashMap.h>
>+#include <wtf/Variant.h>
>+#include <wtf/Vector.h>
>+#include <wtf/text/WTFString.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+class NameContext {
>+public:
>+    NameContext(NameContext* parent = nullptr)
>+        : m_parent(parent)
>+    {
>+    }
>+
>+    bool add(AST::TypeDefinition& typeDefinition)
>+    {
>+        if (exists(typeDefinition.name()))
>+            return false;
>+        auto result = m_types.add(typeDefinition.name(), Vector<std::reference_wrapper<AST::NamedType>, 1>());
>+        if (!result.isNewEntry)
>+            return false;
>+        result.iterator->value.append(typeDefinition);
>+        return true;
>+    }
>+
>+    bool add(AST::StructureDefinition& structureDefinition)
>+    {
>+        if (exists(structureDefinition.name()))
>+            return false;
>+        auto result = m_types.add(structureDefinition.name(), Vector<std::reference_wrapper<AST::NamedType>, 1>());
>+        if (!result.isNewEntry)
>+            return false;
>+        result.iterator->value.append(structureDefinition);
>+        return true;
>+    }
>+
>+    bool add(AST::EnumerationDefinition& enumerationDefinition)
>+    {
>+        if (exists(enumerationDefinition.name()))
>+            return false;
>+        auto result = m_types.add(enumerationDefinition.name(), Vector<std::reference_wrapper<AST::NamedType>, 1>());
>+        if (!result.isNewEntry)
>+            return false;
>+        result.iterator->value.append(enumerationDefinition);
>+        return true;
>+    }
>+
>+    bool add(AST::FunctionDefinition& functionDefinition)
>+    {
>+        if (m_types.find(functionDefinition.name()) != m_types.end()
>+            || m_variables.find(functionDefinition.name()) != m_variables.end())
>+            return false;
>+        auto result = m_functions.add(functionDefinition.name(), Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1>());
>+        result.iterator->value.append(functionDefinition);
>+        return true;
>+    }
>+
>+    bool add(AST::NativeFunctionDeclaration& nativeFunctionDeclaration)
>+    {
>+        if (m_types.find(nativeFunctionDeclaration.name()) != m_types.end()
>+            || m_variables.find(nativeFunctionDeclaration.name()) != m_variables.end())
>+            return false;
>+        auto result = m_functions.add(nativeFunctionDeclaration.name(), Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1>());
>+        result.iterator->value.append(nativeFunctionDeclaration);
>+        return true;
>+    }
>+
>+    bool add(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+    {
>+        if (m_functions.find(nativeTypeDeclaration.name()) != m_functions.end()
>+            || m_variables.find(nativeTypeDeclaration.name()) != m_variables.end())
>+            return false;
>+        auto result = m_types.add(nativeTypeDeclaration.name(), Vector<std::reference_wrapper<AST::NamedType>, 1>());
>+        result.iterator->value.append(nativeTypeDeclaration);
>+        return true;
>+    }
>+
>+    bool add(AST::VariableDeclaration& variableDeclaration)
>+    {
>+        if (exists(variableDeclaration.name()))
>+            return false;
>+        auto result = m_variables.add(String(variableDeclaration.name()), &variableDeclaration);
>+        return result.isNewEntry;
>+    }
>+
>+    Vector<std::reference_wrapper<AST::NamedType>, 1>* getTypes(const String& name)
>+    {
>+        auto iterator = m_types.find(name);
>+        if (iterator == m_types.end()) {
>+            if (m_parent)
>+                return m_parent->getTypes(name);
>+            return nullptr;
>+        }
>+        return &iterator->value;
>+    }
>+
>+    Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1>* getFunctions(const String& name)
>+    {
>+        auto iterator = m_functions.find(name);
>+        if (iterator == m_functions.end()) {
>+            if (m_parent)
>+                return m_parent->getFunctions(name);
>+            return nullptr;
>+        }
>+        return &iterator->value;
>+    }
>+
>+    AST::VariableDeclaration* getVariable(const String& name)
>+    {
>+        auto iterator = m_variables.find(name);
>+        if (iterator == m_variables.end()) {
>+            if (m_parent)
>+                return m_parent->getVariable(name);
>+            return nullptr;
>+        }
>+        return iterator->value;
>+    }
>+
>+private:
>+    bool exists(String& name)
>+    {
>+        return m_types.find(name) != m_types.end()
>+            || m_functions.find(name) != m_functions.end()
>+            || m_variables.find(name) != m_variables.end();
>+    }
>+
>+    HashMap<String, Vector<std::reference_wrapper<AST::NamedType>, 1>> m_types;
>+    HashMap<String, Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1>> m_functions;
>+    HashMap<String, AST::VariableDeclaration*> m_variables;
>+    NameContext* m_parent;
>+};
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.h
>index 47d4d6a5793..d0d5b637152 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.h
>@@ -27,13 +27,296 @@
> 
> #if ENABLE(WEBGPU)
> 
>+#include "WHLSLEnumerationMemberLiteral.h"
>+#include "WHLSLNameContext.h"
> #include "WHLSLProgram.h"
>+#include "WHLSLResolveOverloadImpl.h"
>+#include "WHLSLVisitor.h"
>+#include <wtf/Optional.h>
>+#include <wtf/Variant.h>
> 
> namespace WebCore {
> 
> namespace WHLSL {
> 
>-void resolveNamesInTypes(Program& program);
>+class NameResolver : public Visitor {
>+public:
>+    NameResolver(NameContext& nameContext)
>+        : m_nameContext(nameContext)
>+    {
>+    }
>+
>+    virtual ~NameResolver() = default;
>+
>+    void visit(AST::TypeReference& typeReference) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        Visitor::visit(typeReference);
>+        if (typeReference.resolvedType())
>+            return;
>+
>+        auto* candidates = m_nameContext.getTypes(typeReference.name());
>+        if (candidates == nullptr) {
>+            m_error = true;
>+            return;
>+        }
>+        if (auto result = resolveTypeOverloadImpl(*candidates, typeReference.typeArguments()))
>+            typeReference.setResolvedType(*result);
>+        else {
>+            m_error = true;
>+            return;
>+        }
>+    }
>+
>+    void visit(AST::FunctionDefinition& functionDefinition) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        NameContext newNameContext(&m_nameContext);
>+        NameResolver newNameResolver(newNameContext);
>+        visitUnnamedType(functionDefinition.type());
>+        for (auto& parameter : functionDefinition.parameters()) {
>+            newNameResolver.Visitor::visit(parameter);
>+            auto success = newNameContext.add(parameter);
>+            if (!success) {
>+                m_error = true;
>+                return;
>+            }
>+        }
>+        newNameResolver.visit(functionDefinition.block());
>+    }
>+
>+    void visit(AST::Block& block) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        NameContext nameContext(&m_nameContext);
>+        NameResolver(nameContext).Visitor::visit(block);
>+    }
>+
>+    void visit(AST::IfStatement& ifStatement) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        Visitor::visit(ifStatement.conditional());
>+        NameContext nameContext(&m_nameContext);
>+        NameResolver(nameContext).Visitor::visit(ifStatement.body());
>+        if (ifStatement.elseBody()) {
>+            NameContext nameContext(&m_nameContext);
>+            NameResolver(nameContext).Visitor::visit(*ifStatement.elseBody());
>+        }
>+    }
>+
>+    void visit(AST::WhileLoop& whileLoop) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        Visitor::visit(whileLoop.conditional());
>+        NameContext nameContext(&m_nameContext);
>+        NameResolver(nameContext).Visitor::visit(whileLoop.body());
>+    }
>+
>+    void visit(AST::DoWhileLoop& whileLoop) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        NameContext nameContext(&m_nameContext);
>+        NameResolver(nameContext).Visitor::visit(whileLoop.body());
>+        Visitor::visit(whileLoop.conditional());
>+    }
>+
>+    void visit(AST::ForLoop& forLoop) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        NameContext nameContext(&m_nameContext);
>+        NameResolver(nameContext).Visitor::visit(forLoop);
>+    }
>+
>+    void visit(AST::VariableDeclaration& variableDeclaration) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        m_nameContext.add(variableDeclaration);
>+        Visitor::visit(variableDeclaration);
>+    }
>+
>+    void visit(AST::VariableReference& variableReference) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        if (variableReference.variable())
>+            return;
>+
>+        if (auto* variable = m_nameContext.getVariable(variableReference.name()))
>+            variableReference.setVariable(*variable);
>+        else {
>+            m_error = true;
>+            return;
>+        }
>+    }
>+
>+    void visit(AST::Return& returnNode) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        ASSERT(m_currentFunction);
>+        returnNode.setFunction(m_currentFunction);
>+        Visitor::visit(returnNode);
>+    }
>+
>+    void visit(AST::PropertyAccessExpression& propertyAccessExpression) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        if (auto* getFunctions = m_nameContext.getFunctions(propertyAccessExpression.getFunctionName()))
>+            propertyAccessExpression.setPossibleGetOverloads(*getFunctions);
>+        if (auto* setFunctions = m_nameContext.getFunctions(propertyAccessExpression.setFunctionName()))
>+            propertyAccessExpression.setPossibleSetOverloads(*setFunctions);
>+        if (auto* andFunctions = m_nameContext.getFunctions(propertyAccessExpression.andFunctionName()))
>+            propertyAccessExpression.setPossibleAndOverloads(*andFunctions);
>+        Visitor::visit(propertyAccessExpression);
>+    }
>+
>+    void visit(AST::DotExpression& dotExpression) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        if (is<AST::VariableReference>(dotExpression.base())) {
>+            if (auto enumerationTypes = m_nameContext.getTypes(downcast<AST::VariableReference>(dotExpression.base()).name())) {
>+                ASSERT(enumerationTypes->size() == 1);
>+                AST::NamedType& type = (*enumerationTypes)[0];
>+                if (is<AST::EnumerationDefinition>(type)) {
>+                    AST::EnumerationDefinition& enumerationDefinition = downcast<AST::EnumerationDefinition>(type);
>+                    if (auto* member = enumerationDefinition.memberByName(dotExpression.fieldName())) {
>+                        static_assert(sizeof(AST::EnumerationMemberLiteral) <= sizeof(AST::DotExpression), "Dot expressions need to be able to become EnumerationMemberLiterals without updating backreferences");
>+                        Lexer::Token origin = dotExpression.origin();
>+                        // FIXME: Perhaps do this with variants or a Rewriter instead.
>+                        dotExpression.~DotExpression();
>+                        new (&dotExpression) AST::EnumerationMemberLiteral(WTFMove(origin), *member);
>+                        return;
>+                    } else {
>+                        m_error = true;
>+                        return;
>+                    }
>+                }
>+            }
>+        }
>+
>+        Visitor::visit(dotExpression);
>+    }
>+
>+    void visit(AST::CallExpression& callExpression) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        if (!callExpression.hasOverloads()) {
>+            if (auto* functions = m_nameContext.getFunctions(callExpression.name()))
>+                callExpression.setOverloads(*functions);
>+            else {
>+                callExpression.setCastData();
>+                if (auto* functions = m_nameContext.getFunctions(callExpression.name()))
>+                    callExpression.setOverloads(*functions);
>+                else {
>+                    m_error = true;
>+                    return;
>+                }
>+            }
>+        }
>+        Visitor::visit(callExpression);
>+    }
>+
>+    void visit(AST::ConstantExpressionEnumerationMemberReference& constantExpressionEnumerationMemberReference) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        if (auto enumerationTypes = m_nameContext.getTypes(constantExpressionEnumerationMemberReference.left())) {
>+            ASSERT(enumerationTypes->size() == 1);
>+            AST::NamedType& type = (*enumerationTypes)[0];
>+            if (is<AST::EnumerationDefinition>(type)) {
>+                AST::EnumerationDefinition& enumerationDefinition = downcast<AST::EnumerationDefinition>(type);
>+                if (auto* member = enumerationDefinition.memberByName(constantExpressionEnumerationMemberReference.right())) {
>+                    constantExpressionEnumerationMemberReference.setEnumerationMember(*member);
>+                    return;
>+                }
>+            }
>+        }
>+        
>+        m_error = true;
>+    }
>+
>+    // FIXME: Make sure all the names have been resolved.
>+
>+    void setCurrentFunctionDefinition(AST::FunctionDefinition* functionDefinition)
>+    {
>+        m_currentFunction = functionDefinition;
>+    }
>+
>+    bool error() { return m_error; }
>+
>+private:
>+    NameContext m_nameContext;
>+    AST::FunctionDefinition* m_currentFunction { nullptr };
>+    bool m_error { false }; // FIXME: Migrate this to be some sort of descriptive string.
>+    // FIXME: Consider moving the error into Visitor
>+};
>+
>+inline bool resolveNamesInTypes(Program& program, NameResolver& nameResolver)
>+{
>+    for (auto& typeDefinition : program.typeDefinitions()) {
>+        nameResolver.Visitor::visit(*typeDefinition);
>+        if (nameResolver.error())
>+            return false;
>+    }
>+    for (auto& structureDefinition : program.structureDefinitions()) {
>+        nameResolver.Visitor::visit(*structureDefinition);
>+        if (nameResolver.error())
>+            return false;
>+    }
>+    for (auto& enumerationDefinition : program.enumerationDefinitions()) {
>+        nameResolver.Visitor::visit(*enumerationDefinition);
>+        if (nameResolver.error())
>+            return false;
>+    }
>+    for (auto& nativeTypeDeclaration : program.nativeTypeDeclarations()) {
>+        nameResolver.Visitor::visit(*nativeTypeDeclaration);
>+        if (nameResolver.error())
>+            return false;
>+    }
>+    return true;
>+}
>+
>+inline bool resolveNamesInFunctions(Program& program, NameResolver& nameResolver)
>+{
>+    for (auto& functionDefinition : program.functionDefinitions()) {
>+        nameResolver.setCurrentFunctionDefinition(functionDefinition.get());
>+        nameResolver.visit(*functionDefinition);
>+        if (nameResolver.error())
>+            return false;
>+    }
>+    nameResolver.setCurrentFunctionDefinition(nullptr);
>+    for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations()) {
>+        nameResolver.Visitor::visit(*nativeFunctionDeclaration);
>+        if (nameResolver.error())
>+            return false;
>+    }
>+    return true;
>+}
> 
> }
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>index bc6e73e6a1f..e72ec6d6d9e 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>@@ -38,7 +38,8 @@ Parser::Parser()
> {
> }
> 
>-auto Parser::parse(Program& result, StringView stringView, Mode mode) -> Optional<Error>
>+// FIXME: Return a better error code from this, and report it to JavaScript.
>+auto Parser::parse(Program& program, StringView stringView, Mode mode) -> Optional<Error>
> {
>     m_lexer = Lexer(stringView);
>     m_mode = mode;
>@@ -54,7 +55,11 @@ auto Parser::parse(Program& result, StringView stringView, Mode mode) -> Optiona
>                 return parseTypeDefinition();
>             });
>             if (typeDefinition) {
>-                result.append(WTFMove(*typeDefinition));
>+                auto success = program.append(WTFMove(*typeDefinition));
>+                if (!success) {
>+                    WTFLogAlways("Name Error! %s", typeDefinition->name().utf8().data());
>+                    return WTF::nullopt;
>+                }
>                 continue;
>             }
>         }
>@@ -64,7 +69,11 @@ auto Parser::parse(Program& result, StringView stringView, Mode mode) -> Optiona
>                 return parseStructureDefinition();
>             });
>             if (structureDefinition) {
>-                result.append(WTFMove(*structureDefinition));
>+                auto success = program.append(WTFMove(*structureDefinition));
>+                if (!success) {
>+                    WTFLogAlways("Name Error! %s", structureDefinition->name().utf8().data());
>+                    return WTF::nullopt;
>+                }
>                 continue;
>             }
>         }
>@@ -74,7 +83,11 @@ auto Parser::parse(Program& result, StringView stringView, Mode mode) -> Optiona
>                 return parseEnumerationDefinition();
>             });
>             if (enumerationDefinition) {
>-                result.append(WTFMove(*enumerationDefinition));
>+                auto success = program.append(WTFMove(*enumerationDefinition));
>+                if (!success) {
>+                    WTFLogAlways("Name Error! %s", enumerationDefinition->name().utf8().data());
>+                    return WTF::nullopt;
>+                }
>                 continue;
>             }
>         }
>@@ -85,7 +98,11 @@ auto Parser::parse(Program& result, StringView stringView, Mode mode) -> Optiona
>                 return parseFunctionDefinition();
>             });
>             if (functionDefinition) {
>-                result.append(WTFMove(*functionDefinition));
>+                auto success = program.append(WTFMove(*functionDefinition));
>+                if (!success) {
>+                    WTFLogAlways("Name Error! %s", functionDefinition->name().utf8().data());
>+                    return WTF::nullopt;
>+                }
>                 continue;
>             }
>             error = functionDefinition.error();
>@@ -96,7 +113,11 @@ auto Parser::parse(Program& result, StringView stringView, Mode mode) -> Optiona
>                 return parseNativeFunctionDeclaration();
>             });
>             if (nativeFunctionDeclaration) {
>-                result.append(WTFMove(*nativeFunctionDeclaration));
>+                auto success = program.append(WTFMove(*nativeFunctionDeclaration));
>+                if (!success) {
>+                    WTFLogAlways("Name Error! %s", nativeFunctionDeclaration->name().utf8().data());
>+                    return WTF::nullopt;
>+                }
>                 continue;
>             }
>         }
>@@ -106,7 +127,11 @@ auto Parser::parse(Program& result, StringView stringView, Mode mode) -> Optiona
>                 return parseNativeTypeDeclaration();
>             });
>             if (nativeTypeDeclaration) {
>-                result.append(WTFMove(*nativeTypeDeclaration));
>+                auto success = program.append(WTFMove(*nativeTypeDeclaration));
>+                if (!success) {
>+                    WTFLogAlways("Name Error! %s", nativeTypeDeclaration->name().utf8().data());
>+                    return WTF::nullopt;
>+                }
>                 continue;
>             }
>         }
>@@ -454,16 +479,52 @@ auto Parser::parseTypeSuffixNonAbbreviated() -> Expected<TypeSuffixNonAbbreviate
>             return Unexpected<Error>(rightSquareBracket.error());
>         return {{ *token, WTF::nullopt, *numElements }};
>     }
>-    auto addressSpace = consumeTypes({ Lexer::Token::Type::Constant, Lexer::Token::Type::Device, Lexer::Token::Type::Threadgroup, Lexer::Token::Type::Thread});
>-    if (!addressSpace)
>-        return Unexpected<Error>(addressSpace.error());
>-    return {{ *token, { *addressSpace }, WTF::nullopt }};
>+    auto addressSpaceToken = consumeTypes({ Lexer::Token::Type::Constant, Lexer::Token::Type::Device, Lexer::Token::Type::Threadgroup, Lexer::Token::Type::Thread});
>+    if (!addressSpaceToken)
>+        return Unexpected<Error>(addressSpaceToken.error());
>+    AST::ReferenceType::AddressSpace addressSpace;
>+    switch (addressSpaceToken->type) {
>+    case Lexer::Token::Type::Constant:
>+        addressSpace = AST::ReferenceType::AddressSpace::Constant;
>+        break;
>+    case Lexer::Token::Type::Device:
>+        addressSpace = AST::ReferenceType::AddressSpace::Device;
>+        break;
>+    case Lexer::Token::Type::Threadgroup:
>+        addressSpace = AST::ReferenceType::AddressSpace::Threadgroup;
>+        break;
>+    case Lexer::Token::Type::Thread:
>+        addressSpace = AST::ReferenceType::AddressSpace::Thread;
>+        break;
>+    default:
>+        ASSERT_NOT_REACHED();
>+        return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral)));
>+    }
>+    return {{ *token, { addressSpace }, WTF::nullopt }};
> }
> 
>-auto Parser::parseAddressSpaceType() -> Expected<std::unique_ptr<AST::Type>, Error> {
>-    auto addressSpace = consumeTypes({ Lexer::Token::Type::Constant, Lexer::Token::Type::Device, Lexer::Token::Type::Threadgroup, Lexer::Token::Type::Thread});
>-    if (!addressSpace)
>-        return Unexpected<Error>(addressSpace.error());
>+auto Parser::parseAddressSpaceType() -> Expected<std::unique_ptr<AST::UnnamedType>, Error> {
>+    auto addressSpaceToken = consumeTypes({ Lexer::Token::Type::Constant, Lexer::Token::Type::Device, Lexer::Token::Type::Threadgroup, Lexer::Token::Type::Thread});
>+    if (!addressSpaceToken)
>+        return Unexpected<Error>(addressSpaceToken.error());
>+    AST::ReferenceType::AddressSpace addressSpace;
>+    switch (addressSpaceToken->type) {
>+    case Lexer::Token::Type::Constant:
>+        addressSpace = AST::ReferenceType::AddressSpace::Constant;
>+        break;
>+    case Lexer::Token::Type::Device:
>+        addressSpace = AST::ReferenceType::AddressSpace::Device;
>+        break;
>+    case Lexer::Token::Type::Threadgroup:
>+        addressSpace = AST::ReferenceType::AddressSpace::Threadgroup;
>+        break;
>+    case Lexer::Token::Type::Thread:
>+        addressSpace = AST::ReferenceType::AddressSpace::Thread;
>+        break;
>+    default:
>+        ASSERT_NOT_REACHED();
>+        return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral)));
>+    }
>     auto name = consumeType(Lexer::Token::Type::Identifier);
>     if (!name)
>         return Unexpected<Error>(name.error());
>@@ -471,12 +532,12 @@ auto Parser::parseAddressSpaceType() -> Expected<std::unique_ptr<AST::Type>, Err
>     if (!typeArguments)
>         return Unexpected<Error>(typeArguments.error());
> 
>-    auto constructTypeFromSuffixAbbreviated = [&](const TypeSuffixAbbreviated& typeSuffixAbbreviated, std::unique_ptr<AST::Type>&& previous) -> std::unique_ptr<AST::Type> {
>+    auto constructTypeFromSuffixAbbreviated = [&](const TypeSuffixAbbreviated& typeSuffixAbbreviated, std::unique_ptr<AST::UnnamedType>&& previous) -> std::unique_ptr<AST::UnnamedType> {
>         switch (typeSuffixAbbreviated.token.type) {
>         case Lexer::Token::Type::Star:
>-            return std::make_unique<AST::PointerType>(Lexer::Token(typeSuffixAbbreviated.token), addressSpace->stringView.toString(), WTFMove(previous));
>+            return std::make_unique<AST::PointerType>(Lexer::Token(typeSuffixAbbreviated.token), addressSpace, WTFMove(previous));
>         case Lexer::Token::Type::SquareBracketPair:
>-            return std::make_unique<AST::ArrayReferenceType>(Lexer::Token(typeSuffixAbbreviated.token), addressSpace->stringView.toString(), WTFMove(previous));
>+            return std::make_unique<AST::ArrayReferenceType>(Lexer::Token(typeSuffixAbbreviated.token), addressSpace, WTFMove(previous));
>         case Lexer::Token::Type::LeftSquareBracket:
>             return std::make_unique<AST::ArrayType>(Lexer::Token(typeSuffixAbbreviated.token), WTFMove(previous), *typeSuffixAbbreviated.numElements);
>         default:
>@@ -488,7 +549,7 @@ auto Parser::parseAddressSpaceType() -> Expected<std::unique_ptr<AST::Type>, Err
>     auto firstTypeSuffixAbbreviated = parseTypeSuffixAbbreviated();
>     if (!firstTypeSuffixAbbreviated)
>         return Unexpected<Error>(firstTypeSuffixAbbreviated.error());
>-    std::unique_ptr<AST::Type> result = std::make_unique<AST::TypeReference>(Lexer::Token(*addressSpace), name->stringView.toString(), WTFMove(*typeArguments));
>+    std::unique_ptr<AST::UnnamedType> result = std::make_unique<AST::TypeReference>(WTFMove(*addressSpaceToken), name->stringView.toString(), WTFMove(*typeArguments));
>     result = constructTypeFromSuffixAbbreviated(*firstTypeSuffixAbbreviated, WTFMove(result));
>     while (true) {
>         auto typeSuffixAbbreviated = backtrackingScope<Expected<TypeSuffixAbbreviated, Error>>([&]() {
>@@ -503,7 +564,7 @@ auto Parser::parseAddressSpaceType() -> Expected<std::unique_ptr<AST::Type>, Err
>     return WTFMove(result);
> }
> 
>-auto Parser::parseNonAddressSpaceType() -> Expected<std::unique_ptr<AST::Type>, Error> {
>+auto Parser::parseNonAddressSpaceType() -> Expected<std::unique_ptr<AST::UnnamedType>, Error> {
>     auto origin = peek();
>     if (!origin)
>         return Unexpected<Error>(origin.error());
>@@ -514,12 +575,12 @@ auto Parser::parseNonAddressSpaceType() -> Expected<std::unique_ptr<AST::Type>,
>     if (!typeArguments)
>         return Unexpected<Error>(typeArguments.error());
> 
>-    auto constructTypeFromSuffixNonAbbreviated = [&](const TypeSuffixNonAbbreviated& typeSuffixNonAbbreviated, std::unique_ptr<AST::Type>&& previous) -> std::unique_ptr<AST::Type> {
>+    auto constructTypeFromSuffixNonAbbreviated = [&](const TypeSuffixNonAbbreviated& typeSuffixNonAbbreviated, std::unique_ptr<AST::UnnamedType>&& previous) -> std::unique_ptr<AST::UnnamedType> {
>         switch (typeSuffixNonAbbreviated.token.type) {
>         case Lexer::Token::Type::Star:
>-            return std::make_unique<AST::PointerType>(Lexer::Token(typeSuffixNonAbbreviated.token), typeSuffixNonAbbreviated.addressSpace->stringView.toString(), WTFMove(previous));
>+            return std::make_unique<AST::PointerType>(Lexer::Token(typeSuffixNonAbbreviated.token), *typeSuffixNonAbbreviated.addressSpace, WTFMove(previous));
>         case Lexer::Token::Type::SquareBracketPair:
>-            return std::make_unique<AST::ArrayReferenceType>(Lexer::Token(typeSuffixNonAbbreviated.token), typeSuffixNonAbbreviated.addressSpace->stringView.toString(), WTFMove(previous));
>+            return std::make_unique<AST::ArrayReferenceType>(Lexer::Token(typeSuffixNonAbbreviated.token), *typeSuffixNonAbbreviated.addressSpace, WTFMove(previous));
>         case Lexer::Token::Type::LeftSquareBracket:
>             return std::make_unique<AST::ArrayType>(Lexer::Token(typeSuffixNonAbbreviated.token), WTFMove(previous), *typeSuffixNonAbbreviated.numElements);
>         default:
>@@ -528,7 +589,7 @@ auto Parser::parseNonAddressSpaceType() -> Expected<std::unique_ptr<AST::Type>,
>         }
>     };
> 
>-    std::unique_ptr<AST::Type> result = std::make_unique<AST::TypeReference>(WTFMove(*origin), name->stringView.toString(), WTFMove(*typeArguments));
>+    std::unique_ptr<AST::UnnamedType> result = std::make_unique<AST::TypeReference>(WTFMove(*origin), name->stringView.toString(), WTFMove(*typeArguments));
>     while (true) {
>         auto typeSuffixNonAbbreviated = backtrackingScope<Expected<TypeSuffixNonAbbreviated, Error>>([&]() {
>             return parseTypeSuffixNonAbbreviated();
>@@ -542,14 +603,14 @@ auto Parser::parseNonAddressSpaceType() -> Expected<std::unique_ptr<AST::Type>,
>     return WTFMove(result);
> }
> 
>-auto Parser::parseType() -> Expected<std::unique_ptr<AST::Type>, Error> {
>-    auto type = backtrackingScope<Expected<std::unique_ptr<AST::Type>, Error>>([&]() {
>+auto Parser::parseType() -> Expected<std::unique_ptr<AST::UnnamedType>, Error> {
>+    auto type = backtrackingScope<Expected<std::unique_ptr<AST::UnnamedType>, Error>>([&]() {
>         return parseAddressSpaceType();
>     });
>     if (type)
>         return type;
> 
>-    type = backtrackingScope<Expected<std::unique_ptr<AST::Type>, Error>>([&]() {
>+    type = backtrackingScope<Expected<std::unique_ptr<AST::UnnamedType>, Error>>([&]() {
>         return parseNonAddressSpaceType();
>     });
>     if (type)
>@@ -847,7 +908,7 @@ auto Parser::parseEnumerationDefinition() -> Expected<AST::EnumerationDefinition
>     if (!name)
>         return Unexpected<Error>(name.error());
> 
>-    std::unique_ptr<AST::Type> type;
>+    std::unique_ptr<AST::UnnamedType> type;
>     if (tryType(Lexer::Token::Type::Colon)) {
>         auto parsedType = parseType();
>         if (!parsedType)
>@@ -863,21 +924,25 @@ auto Parser::parseEnumerationDefinition() -> Expected<AST::EnumerationDefinition
>     if (!firstEnumerationMember)
>         return Unexpected<Error>(firstEnumerationMember.error());
> 
>-    AST::EnumerationMembers members;
>-    members.append(WTFMove(*firstEnumerationMember));
>+    AST::EnumerationDefinition result(WTFMove(*origin), name->stringView.toString(), WTFMove(type));
>+    auto success = result.add(WTFMove(*firstEnumerationMember));
>+    if (!success)
>+        return fail(String("Cannot add enumeration member", String::ConstructFromLiteral));
> 
>     while (tryType(Lexer::Token::Type::Comma)) {
>         auto member = parseEnumerationMember();
>         if (!member)
>             return Unexpected<Error>(member.error());
>-        members.append(WTFMove(*member));
>+        success = result.add(WTFMove(*member));
>+        if (!success)
>+            return fail(String("Cannot add enumeration member", String::ConstructFromLiteral));
>     }
> 
>     auto rightCurlyBracket = consumeType(Lexer::Token::Type::RightCurlyBracket);
>     if (!rightCurlyBracket)
>         return Unexpected<Error>(rightCurlyBracket.error());
> 
>-    return AST::EnumerationDefinition(WTFMove(*origin), name->stringView.toString(), WTFMove(type), WTFMove(members));
>+    return WTFMove(result);
> }
> 
> auto Parser::parseEnumerationMember() -> Expected<AST::EnumerationMember, Error> {
>@@ -981,7 +1046,7 @@ auto Parser::parseAttributeBlock() -> Expected<AST::AttributeBlock, Error> {
>     return WTFMove(result);
> }
> 
>-auto Parser::parseParameter() -> Expected<AST::Parameter, Error> {
>+auto Parser::parseParameter() -> Expected<AST::VariableDeclaration, Error> {
>     auto origin = peek();
>     if (!origin)
>         return Unexpected<Error>(origin.error());
>@@ -992,7 +1057,7 @@ auto Parser::parseParameter() -> Expected<AST::Parameter, Error> {
>     if (!type)
>         return Unexpected<Error>(type.error());
> 
>-    Optional<String> name;
>+    String name;
>     if (auto token = tryType(Lexer::Token::Type::Identifier))
>         name = token->stringView.toString();
> 
>@@ -1000,18 +1065,18 @@ auto Parser::parseParameter() -> Expected<AST::Parameter, Error> {
>         auto semantic = parseSemantic();
>         if (!semantic)
>             return Unexpected<Error>(semantic.error());
>-        return AST::Parameter(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), WTFMove(name), WTFMove(*semantic));
>+        return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), WTFMove(name), WTFMove(*semantic), nullptr);
>     }
> 
>-    return AST::Parameter(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), WTFMove(name), WTF::nullopt);
>+    return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), WTFMove(name), WTF::nullopt, nullptr);
> }
> 
>-auto Parser::parseParameters() -> Expected<AST::Parameters, Error> {
>+auto Parser::parseParameters() -> Expected<AST::VariableDeclarations, Error> {
>     auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
>     if (!leftParenthesis)
>         return Unexpected<Error>(leftParenthesis.error());
> 
>-    AST::Parameters parameters;
>+    AST::VariableDeclarations parameters;
>     if (tryType(Lexer::Token::Type::RightParenthesis))
>         return WTFMove(parameters);
> 
>@@ -1443,7 +1508,7 @@ auto Parser::parseDoWhileLoop() -> Expected<AST::DoWhileLoop, Error> {
>     return AST::DoWhileLoop(WTFMove(*origin), WTFMove(*body), WTFMove(*conditional));
> }
> 
>-auto Parser::parseVariableDeclaration(std::unique_ptr<AST::Type>&& type) -> Expected<AST::VariableDeclaration, Error> {
>+auto Parser::parseVariableDeclaration(std::unique_ptr<AST::UnnamedType>&& type) -> Expected<AST::VariableDeclaration, Error> {
>     auto origin = peek();
>     if (!origin)
>         return Unexpected<Error>(origin.error());
>@@ -1488,7 +1553,7 @@ auto Parser::parseVariableDeclarations() -> Expected<AST::VariableDeclarationsSt
>     if (!type)
>         return Unexpected<Error>(type.error());
> 
>-    auto firstVariableDeclaration = parseVariableDeclaration(std::unique_ptr<AST::Type>((*type)->clone()));
>+    auto firstVariableDeclaration = parseVariableDeclaration((*type)->clone());
>     if (!firstVariableDeclaration)
>         return Unexpected<Error>(firstVariableDeclaration.error());
> 
>@@ -1496,7 +1561,7 @@ auto Parser::parseVariableDeclarations() -> Expected<AST::VariableDeclarationsSt
>     result.append(WTFMove(*firstVariableDeclaration));
> 
>     while (tryType(Lexer::Token::Type::Comma)) {
>-        auto variableDeclaration = parseVariableDeclaration(std::unique_ptr<AST::Type>((*type)->clone()));
>+        auto variableDeclaration = parseVariableDeclaration((*type)->clone());
>         if (!variableDeclaration)
>             return Unexpected<Error>(variableDeclaration.error());
>         result.append(WTFMove(*variableDeclaration));
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h
>index da3e06b01e4..80139149804 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h
>@@ -27,7 +27,6 @@
> 
> #if ENABLE(WEBGPU)
> 
>-#include "WHLSLAnonymousVariableDeclaration.h"
> #include "WHLSLArrayReferenceType.h"
> #include "WHLSLArrayType.h"
> #include "WHLSLAssignmentExpression.h"
>@@ -68,7 +67,6 @@
> #include "WHLSLNode.h"
> #include "WHLSLNullLiteral.h"
> #include "WHLSLNumThreadsFunctionAttribute.h"
>-#include "WHLSLParameter.h"
> #include "WHLSLPointerType.h"
> #include "WHLSLProgram.h"
> #include "WHLSLPropertyAccessExpression.h"
>@@ -154,13 +152,13 @@ private:
>     Expected<TypeSuffixAbbreviated, Error> parseTypeSuffixAbbreviated();
>     struct TypeSuffixNonAbbreviated {
>         Lexer::Token token;
>-        Optional<Lexer::Token> addressSpace;
>+        Optional<AST::ReferenceType::AddressSpace> addressSpace;
>         Optional<unsigned> numElements;
>     };
>     Expected<TypeSuffixNonAbbreviated, Error> parseTypeSuffixNonAbbreviated();
>-    Expected<std::unique_ptr<AST::Type>, Error> parseAddressSpaceType();
>-    Expected<std::unique_ptr<AST::Type>, Error> parseNonAddressSpaceType();
>-    Expected<std::unique_ptr<AST::Type>, Error> parseType();
>+    Expected<std::unique_ptr<AST::UnnamedType>, Error> parseAddressSpaceType();
>+    Expected<std::unique_ptr<AST::UnnamedType>, Error> parseNonAddressSpaceType();
>+    Expected<std::unique_ptr<AST::UnnamedType>, Error> parseType();
>     Expected<AST::TypeDefinition, Error> parseTypeDefinition();
>     Expected<AST::BuiltInSemantic, Error> parseBuiltInSemantic();
>     Expected<AST::ResourceSemantic, Error> parseResourceSemantic();
>@@ -175,8 +173,8 @@ private:
>     Expected<AST::NativeTypeDeclaration, Error> parseNativeTypeDeclaration();
>     Expected<AST::NumThreadsFunctionAttribute, Error> parseNumThreadsFunctionAttribute();
>     Expected<AST::AttributeBlock, Error> parseAttributeBlock();
>-    Expected<AST::Parameter, Error> parseParameter();
>-    Expected<AST::Parameters, Error> parseParameters();
>+    Expected<AST::VariableDeclaration, Error> parseParameter();
>+    Expected<AST::VariableDeclarations, Error> parseParameters();
>     Expected<AST::FunctionDeclaration, Error> parseEntryPointFunctionDeclaration();
>     Expected<AST::FunctionDeclaration, Error> parseRegularFunctionDeclaration();
>     Expected<AST::FunctionDeclaration, Error> parseOperatorFunctionDeclaration();
>@@ -192,7 +190,7 @@ private:
>     Expected<AST::ForLoop, Error> parseForLoop();
>     Expected<AST::WhileLoop, Error> parseWhileLoop();
>     Expected<AST::DoWhileLoop, Error> parseDoWhileLoop();
>-    Expected<AST::VariableDeclaration, Error> parseVariableDeclaration(std::unique_ptr<AST::Type>&&);
>+    Expected<AST::VariableDeclaration, Error> parseVariableDeclaration(std::unique_ptr<AST::UnnamedType>&&);
>     Expected<AST::VariableDeclarationsStatement, Error> parseVariableDeclarations();
>     Expected<std::unique_ptr<AST::Statement>, Error> parseStatement();
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>index 0eb64decd4d..b39795f52a1 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>@@ -28,10 +28,15 @@
> #include "config.h"
> #include "WHLSLPrepare.h"
> 
>+#include "WHLSLCheckDuplicateFunctions.h"
> #include "WHLSLNameResolver.h"
> #include "WHLSLParser.h"
> #include "WHLSLProgram.h"
>+#include "WHLSLRecursiveTypeChecker.h"
> #include "WHLSLStandardLibrary.h"
>+#include "WHLSLSynthesizeArrayOperatorLength.h"
>+#include "WHLSLSynthesizeEnumerationFunctions.h"
>+#include "WHLSLSynthesizeStructureAccessors.h"
> 
> namespace WebCore {
> 
>@@ -50,7 +55,18 @@ Optional<PreparationResult> prepare(StringView source)
>     if (!success)
>         return WTF::nullopt;
> 
>-    resolveNamesInTypes(program);
>+    NameResolver nameResolver(program.nameContext());
>+    if (!resolveNamesInTypes(program, nameResolver))
>+        return WTF::nullopt;
>+    if (!checkRecursiveTypes(program))
>+        return WTF::nullopt;
>+    synthesizeStructureAccessors(program);
>+    synthesizeEnumerationFunctions(program);
>+    synthesizeArrayOperatorLength(program);
>+    if (!checkDuplicateFunctions(program))
>+        return WTF::nullopt;
>+    if (!resolveNamesInFunctions(program, nameResolver))
>+        return WTF::nullopt;
> 
>     return PreparationResult();
> }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLProgram.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLProgram.h
>index 5630fe69ee4..66f75f69eb8 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLProgram.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLProgram.h
>@@ -29,6 +29,8 @@
> 
> #include "WHLSLEnumerationDefinition.h"
> #include "WHLSLFunctionDefinition.h"
>+#include "WHLSLIntrinsics.h"
>+#include "WHLSLNameContext.h"
> #include "WHLSLNativeFunctionDeclaration.h"
> #include "WHLSLNativeTypeDeclaration.h"
> #include "WHLSLStructureDefinition.h"
>@@ -44,45 +46,63 @@ public:
>     Program() = default;
>     Program(Program&&) = default;
> 
>-    void append(AST::TypeDefinition&& typeDefinition)
>+    bool append(AST::TypeDefinition&& typeDefinition)
>     {
>-        m_typeDefinitions.append(WTFMove(typeDefinition));
>+        m_typeDefinitions.append(std::make_unique<AST::TypeDefinition>(WTFMove(typeDefinition)));
>+        return m_nameContext.add(*m_typeDefinitions.last());
>     }
>-    void append(AST::StructureDefinition&& structureDefinition)
>+
>+    bool append(AST::StructureDefinition&& structureDefinition)
>     {
>-        m_structureDefinitions.append(WTFMove(structureDefinition));
>+        m_structureDefinitions.append(std::make_unique<AST::StructureDefinition>(WTFMove(structureDefinition)));
>+        return m_nameContext.add(*m_structureDefinitions.last());
>     }
>-    void append(AST::EnumerationDefinition&& enumerationDefinition)
>+
>+    bool append(AST::EnumerationDefinition&& enumerationDefinition)
>     {
>-        m_enumerationDefinitions.append(WTFMove(enumerationDefinition));
>+        m_enumerationDefinitions.append(std::make_unique<AST::EnumerationDefinition>(WTFMove(enumerationDefinition)));
>+        return m_nameContext.add(*m_enumerationDefinitions.last());
>     }
>-    void append(AST::FunctionDefinition&& functionDefinition)
>+
>+    bool append(AST::FunctionDefinition&& functionDefinition)
>     {
>-        m_functionDefinitions.append(WTFMove(functionDefinition));
>+        m_functionDefinitions.append(std::make_unique<AST::FunctionDefinition>(WTFMove(functionDefinition)));
>+        return m_nameContext.add(*m_functionDefinitions.last());
>     }
>-    void append(AST::NativeFunctionDeclaration&& nativeFunctionDeclaration)
>+
>+    bool append(AST::NativeFunctionDeclaration&& nativeFunctionDeclaration)
>     {
>-        m_nativeFunctionDeclarations.append(WTFMove(nativeFunctionDeclaration));
>+        m_nativeFunctionDeclarations.append(std::make_unique<AST::NativeFunctionDeclaration>(WTFMove(nativeFunctionDeclaration)));
>+        m_intrinsics.add(*m_nativeFunctionDeclarations.last());
>+        return m_nameContext.add(*m_nativeFunctionDeclarations.last());
>     }
>-    void append(AST::NativeTypeDeclaration&& nativeTypeDeclaration)
>+
>+    bool append(AST::NativeTypeDeclaration&& nativeTypeDeclaration)
>     {
>-        m_nativeTypeDeclarations.append(WTFMove(nativeTypeDeclaration));
>+        m_nativeTypeDeclarations.append(std::make_unique<AST::NativeTypeDeclaration>(WTFMove(nativeTypeDeclaration)));
>+        m_intrinsics.add(*m_nativeTypeDeclarations.last());
>+        return m_nameContext.add(*m_nativeTypeDeclarations.last());
>     }
> 
>-    Vector<AST::TypeDefinition>& typeDefinitions() { return m_typeDefinitions; }
>-    Vector<AST::StructureDefinition>& structureDefinitions() { return m_structureDefinitions; }
>-    Vector<AST::EnumerationDefinition>& enumerationDefinitions() { return m_enumerationDefinitions; }
>-    Vector<AST::FunctionDefinition>& functionDefinitions() { return m_functionDefinitions; }
>-    Vector<AST::NativeFunctionDeclaration>& nativeFunctionDeclarations() { return m_nativeFunctionDeclarations; }
>-    Vector<AST::NativeTypeDeclaration>& nativeTypeDeclarations() { return m_nativeTypeDeclarations; }
>+    NameContext& nameContext() { return m_nameContext; }
>+    Vector<std::unique_ptr<AST::TypeDefinition>>& typeDefinitions() { return m_typeDefinitions; }
>+    Vector<std::unique_ptr<AST::StructureDefinition>>& structureDefinitions() { return m_structureDefinitions; }
>+    Vector<std::unique_ptr<AST::EnumerationDefinition>>& enumerationDefinitions() { return m_enumerationDefinitions; }
>+    const Vector<std::unique_ptr<AST::FunctionDefinition>>& functionDefinitions() const { return m_functionDefinitions; }
>+    Vector<std::unique_ptr<AST::FunctionDefinition>>& functionDefinitions() { return m_functionDefinitions; }
>+    const Vector<std::unique_ptr<AST::NativeFunctionDeclaration>>& nativeFunctionDeclarations() const { return m_nativeFunctionDeclarations; }
>+    Vector<std::unique_ptr<AST::NativeFunctionDeclaration>>& nativeFunctionDeclarations() { return m_nativeFunctionDeclarations; }
>+    Vector<std::unique_ptr<AST::NativeTypeDeclaration>>& nativeTypeDeclarations() { return m_nativeTypeDeclarations; }
> 
> private:
>-    Vector<AST::TypeDefinition> m_typeDefinitions;
>-    Vector<AST::StructureDefinition> m_structureDefinitions;
>-    Vector<AST::EnumerationDefinition> m_enumerationDefinitions;
>-    Vector<AST::FunctionDefinition> m_functionDefinitions;
>-    Vector<AST::NativeFunctionDeclaration> m_nativeFunctionDeclarations;
>-    Vector<AST::NativeTypeDeclaration> m_nativeTypeDeclarations;
>+    NameContext m_nameContext;
>+    Intrinsics m_intrinsics;
>+    Vector<std::unique_ptr<AST::TypeDefinition>> m_typeDefinitions;
>+    Vector<std::unique_ptr<AST::StructureDefinition>> m_structureDefinitions;
>+    Vector<std::unique_ptr<AST::EnumerationDefinition>> m_enumerationDefinitions;
>+    Vector<std::unique_ptr<AST::FunctionDefinition>> m_functionDefinitions;
>+    Vector<std::unique_ptr<AST::NativeFunctionDeclaration>> m_nativeFunctionDeclarations;
>+    Vector<std::unique_ptr<AST::NativeTypeDeclaration>> m_nativeTypeDeclarations;
> };
> 
> }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursiveTypeChecker.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursiveTypeChecker.h
>new file mode 100644
>index 00000000000..a0d18d87977
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursiveTypeChecker.h
>@@ -0,0 +1,116 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLVisitor.h"
>+#include <wtf/HashSet.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+class RecursiveTypeChecker : public Visitor {
>+public:
>+    ~RecursiveTypeChecker() = default;
>+
>+    void visit(AST::TypeDefinition& typeDefinition) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        auto addResult = m_types.add(&typeDefinition);
>+        if (addResult.isNewEntry) {
>+            m_error = true;
>+            return;
>+        }
>+
>+        Visitor::visit(typeDefinition);
>+
>+        auto success = m_types.remove(&typeDefinition);
>+        ASSERT_UNUSED(success, success);
>+    }
>+
>+    void visit(AST::StructureDefinition& structureDefinition) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        auto addResult = m_types.add(&structureDefinition);
>+        if (addResult.isNewEntry) {
>+            m_error = true;
>+            return;
>+        }
>+
>+        Visitor::visit(structureDefinition);
>+
>+        auto success = m_types.remove(&structureDefinition);
>+        ASSERT_UNUSED(success, success);
>+    }
>+
>+    void visit(AST::TypeReference& typeReference) override
>+    {
>+        if (m_error)
>+            return;
>+
>+        auto addResult = m_types.add(&typeReference);
>+        if (addResult.isNewEntry) {
>+            m_error = true;
>+            return;
>+        }
>+
>+        for (auto& typeArgument : typeReference.typeArguments())
>+            Visitor::visit(typeArgument);
>+        visitNamedType(*typeReference.resolvedType());
>+
>+        auto success = m_types.remove(&typeReference);
>+        ASSERT_UNUSED(success, success);
>+    }
>+
>+    void visit(AST::ReferenceType&) override
>+    {
>+    }
>+
>+    bool error() { return m_error; }
>+
>+private:
>+    bool m_error { false };
>+    HashSet<AST::Type*> m_types;
>+};
>+
>+inline bool checkRecursiveTypes(Program& program)
>+{
>+    RecursiveTypeChecker recursiveTypeChecker;
>+    recursiveTypeChecker.Visitor::visit(program);
>+    return recursiveTypeChecker.error();
>+}
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAnonymousVariableDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLResolveOverloadImpl.h
>similarity index 72%
>rename from Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAnonymousVariableDeclaration.h
>rename to Source/WebCore/Modules/webgpu/WHLSL/WHLSLResolveOverloadImpl.h
>index ef61ed12619..502ba92487d 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAnonymousVariableDeclaration.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLResolveOverloadImpl.h
>@@ -27,33 +27,26 @@
> 
> #if ENABLE(WEBGPU)
> 
>-#include "WHLSLLexer.h"
>-#include "WHLSLValue.h"
>+#include "WHLSLTypeArgument.h"
>+#include "WHLSLInferTypes.h"
>+#include <wtf/Vector.h>
> 
> namespace WebCore {
> 
> namespace WHLSL {
> 
>-namespace AST {
>-
>-class AnonymousVariableDeclaration : public Value {
>-public:
>-    AnonymousVariableDeclaration(Lexer::Token&& origin)
>-        : m_origin(WTFMove(origin))
>-    {
>+inline AST::NamedType* resolveTypeOverloadImpl(Vector<std::reference_wrapper<AST::NamedType>, 1>& possibleTypes, AST::TypeArguments& typeArguments)
>+{
>+    AST::NamedType* result = nullptr;
>+    for (auto& possibleType : possibleTypes) {
>+        if (inferTypesForTypeArguments(possibleType, typeArguments)) {
>+            if (result)
>+                return nullptr;
>+            result = &static_cast<AST::NamedType&>(possibleType);
>+        }
>     }
> 
>-    virtual ~AnonymousVariableDeclaration() = default;
>-
>-    AnonymousVariableDeclaration(const AnonymousVariableDeclaration&) = delete;
>-    AnonymousVariableDeclaration(AnonymousVariableDeclaration&&) = default;
>-
>-    Lexer::Token origin() const { return m_origin; }
>-
>-private:
>-    Lexer::Token m_origin;
>-};
>-
>+    return result;
> }
> 
> }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.h
>new file mode 100644
>index 00000000000..189757252f7
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.h
>@@ -0,0 +1,76 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLProgram.h"
>+#include "WHLSLVisitor.h"
>+#include <wtf/Vector.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+class FindArrayTypes : public Visitor {
>+public:
>+    ~FindArrayTypes() = default;
>+
>+    void visit(AST::ArrayType& arrayType) override
>+    {
>+        m_arrayTypes.append(arrayType);
>+    }
>+
>+    Vector<std::reference_wrapper<AST::ArrayType>>&& takeArrayTypes()
>+    {
>+        return WTFMove(m_arrayTypes);
>+    }
>+
>+private:
>+    Vector<std::reference_wrapper<AST::ArrayType>> m_arrayTypes;
>+};
>+
>+inline void synthesizeArrayOperatorLength(Program& program)
>+{
>+    FindArrayTypes findArrayTypes;
>+    findArrayTypes.Visitor::visit(program);
>+    auto arrayTypes = findArrayTypes.takeArrayTypes();
>+
>+    for (auto& arrayType : arrayTypes) {
>+        AST::VariableDeclaration variableDeclaration(Lexer::Token(arrayType.get().origin()), AST::Qualifiers(),  arrayType.get().clone(), String(), WTF::nullopt, nullptr);
>+        AST::VariableDeclarations parameters;
>+        parameters.append(WTFMove(variableDeclaration));
>+        // FIXME: use "uint" from intrinsics here.
>+        AST::NativeFunctionDeclaration nativeFunctionDeclaration(Lexer::Token(arrayType.get().origin()), AST::AttributeBlock(), WTF::nullopt, arrayType.get().clone(), String("operator.length", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, false);
>+        program.append(WTFMove(nativeFunctionDeclaration));
>+    }
>+}
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.h
>new file mode 100644
>index 00000000000..4936c1962cf
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.h
>@@ -0,0 +1,81 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLProgram.h"
>+#include <wtf/text/WTFString.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+inline void synthesizeEnumerationFunctions(Program& program)
>+{
>+    for (auto& enumerationDefinition : program.enumerationDefinitions()) {
>+        {
>+            AST::VariableDeclaration variableDeclaration1(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), *enumerationDefinition), String(), WTF::nullopt, nullptr);
>+            AST::VariableDeclaration variableDeclaration2(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), *enumerationDefinition), String(), WTF::nullopt, nullptr);
>+            AST::VariableDeclarations parameters;
>+            parameters.append(WTFMove(variableDeclaration1));
>+            parameters.append(WTFMove(variableDeclaration2));
>+            // FIXME: use "bool" from intrinsics here.
>+            AST::NativeFunctionDeclaration nativeFunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), *enumerationDefinition), String("operator==", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, false);
>+            program.append(WTFMove(nativeFunctionDeclaration));
>+        }
>+
>+        {
>+            AST::VariableDeclaration variableDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), *enumerationDefinition), String(), WTF::nullopt, nullptr);
>+            AST::VariableDeclarations parameters;
>+            parameters.append(WTFMove(variableDeclaration));
>+            AST::NativeFunctionDeclaration nativeFunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, enumerationDefinition->type().clone(), String("operator.value", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, false);
>+            program.append(WTFMove(nativeFunctionDeclaration));
>+        }
>+
>+        {
>+            AST::VariableDeclaration variableDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), *enumerationDefinition), String(), WTF::nullopt, nullptr);
>+            AST::VariableDeclarations parameters;
>+            parameters.append(WTFMove(variableDeclaration));
>+            AST::NativeFunctionDeclaration nativeFunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, enumerationDefinition->type().clone(), String("operator cast", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, false);
>+            program.append(WTFMove(nativeFunctionDeclaration));
>+        }
>+
>+        {
>+            AST::VariableDeclaration variableDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), enumerationDefinition->type().clone(), String(), WTF::nullopt, nullptr);
>+            AST::VariableDeclarations parameters;
>+            parameters.append(WTFMove(variableDeclaration));
>+            AST::NativeFunctionDeclaration nativeFunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), *enumerationDefinition), String("operator cast", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, false);
>+            program.append(WTFMove(nativeFunctionDeclaration));
>+        }
>+    }
>+}
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.h
>new file mode 100644
>index 00000000000..c7d7a904998
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.h
>@@ -0,0 +1,83 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLProgram.h"
>+#include <wtf/text/WTFString.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+inline void synthesizeStructureAccessors(Program& program)
>+{
>+    for (auto& structureDefinition : program.structureDefinitions()) {
>+        for (auto& structureElement : structureDefinition->structureElements()) {
>+            {
>+                // The getter: operator.field
>+                AST::VariableDeclaration variableDeclaration(Lexer::Token(structureElement.origin()), AST::Qualifiers(), AST::TypeReference::wrap(Lexer::Token(structureElement.origin()), *structureDefinition), String(), WTF::nullopt, nullptr);
>+                AST::VariableDeclarations parameters;
>+                parameters.append(WTFMove(variableDeclaration));
>+                AST::NativeFunctionDeclaration nativeFunctionDeclaration(Lexer::Token(structureElement.origin()), AST::AttributeBlock(), WTF::nullopt, structureElement.type().clone(), String::format("operator.%s", structureElement.name().utf8().data()), WTFMove(parameters), WTF::nullopt, false);
>+                program.append(WTFMove(nativeFunctionDeclaration));
>+            }
>+
>+            {
>+                // The setter: operator.field=
>+                AST::VariableDeclaration variableDeclaration1(Lexer::Token(structureElement.origin()), AST::Qualifiers(), AST::TypeReference::wrap(Lexer::Token(structureElement.origin()), *structureDefinition), String(), WTF::nullopt, nullptr);
>+                AST::VariableDeclaration variableDeclaration2(Lexer::Token(structureElement.origin()), AST::Qualifiers(), structureElement.type().clone(), String(), WTF::nullopt, nullptr);
>+                AST::VariableDeclarations parameters;
>+                parameters.append(WTFMove(variableDeclaration1));
>+                parameters.append(WTFMove(variableDeclaration2));
>+                AST::NativeFunctionDeclaration nativeFunctionDeclaration(Lexer::Token(structureElement.origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(structureElement.origin()), *structureDefinition), String::format("operator.%s=", structureElement.name().utf8().data()), WTFMove(parameters), WTF::nullopt, false);
>+                program.append(WTFMove(nativeFunctionDeclaration));
>+            }
>+
>+            // The ander: operator&.field
>+            auto createAnder = [&](AST::ReferenceType::AddressSpace addressSpace) -> AST::NativeFunctionDeclaration {
>+                auto argumentType = std::make_unique<AST::PointerType>(Lexer::Token(structureElement.origin()), addressSpace, AST::TypeReference::wrap(Lexer::Token(structureElement.origin()), *structureDefinition));
>+                AST::VariableDeclaration variableDeclaration(Lexer::Token(structureElement.origin()), AST::Qualifiers(), WTFMove(argumentType), String(), WTF::nullopt, nullptr);
>+                AST::VariableDeclarations parameters;
>+                parameters.append(WTFMove(variableDeclaration));
>+                auto returnType = std::make_unique<AST::PointerType>(Lexer::Token(structureElement.origin()), addressSpace, structureElement.type().clone());
>+                AST::NativeFunctionDeclaration nativeFunctionDeclaration(Lexer::Token(structureElement.origin()), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String::format("operator&.%s", structureElement.name().utf8().data()), WTFMove(parameters), WTF::nullopt, false);
>+                return nativeFunctionDeclaration;
>+            };
>+            program.append(createAnder(AST::ReferenceType::AddressSpace::Constant));
>+            program.append(createAnder(AST::ReferenceType::AddressSpace::Device));
>+            program.append(createAnder(AST::ReferenceType::AddressSpace::Threadgroup));
>+            program.append(createAnder(AST::ReferenceType::AddressSpace::Thread));
>+        }
>+    }
>+}
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h
>index 516856e41d0..5f1903e0a95 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h
>@@ -28,7 +28,6 @@
> #if ENABLE(WEBGPU)
> 
> #include "WHLSLProgram.h"
>-#include "WHLSLAnonymousVariableDeclaration.h"
> #include "WHLSLArrayReferenceType.h"
> #include "WHLSLArrayType.h"
> #include "WHLSLAssignmentExpression.h"
>@@ -68,7 +67,6 @@
> #include "WHLSLNode.h"
> #include "WHLSLNullLiteral.h"
> #include "WHLSLNumThreadsFunctionAttribute.h"
>-#include "WHLSLParameter.h"
> #include "WHLSLPointerType.h"
> #include "WHLSLPropertyAccessExpression.h"
> #include "WHLSLQualifier.h"
>@@ -103,41 +101,56 @@ namespace WebCore {
> namespace WHLSL {
> 
> class Visitor {
>-    ~Visitor() = default;
>+public:
>+    virtual ~Visitor() = default;
> 
>     virtual void visit(Program& program)
>     {
>         for (auto& typeDefinition : program.typeDefinitions())
>-            visit(typeDefinition);
>+            visit(*typeDefinition);
>         for (auto& structureDefinition : program.structureDefinitions())
>-            visit(structureDefinition);
>+            visit(*structureDefinition);
>         for (auto& enumerationDefinition : program.enumerationDefinitions())
>-            visit(enumerationDefinition);
>+            visit(*enumerationDefinition);
>         for (auto& functionDefinition : program.functionDefinitions())
>-            visit(functionDefinition);
>+            visit(*functionDefinition);
>         for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations())
>-            visit(nativeFunctionDeclaration);
>+            visit(*nativeFunctionDeclaration);
>         for (auto& nativeTypeDeclaration : program.nativeTypeDeclarations())
>-            visit(nativeTypeDeclaration);
>+            visit(*nativeTypeDeclaration);
>     }
> 
>-    void visitType(AST::Type& type)
>+    void visitUnnamedType(AST::UnnamedType& unnamedType)
>     {
>-        if (is<AST::TypeReference>(type))
>-            visit(downcast<AST::TypeReference>(type));
>-        else if (is<AST::PointerType>(type))
>-            visit(downcast<AST::PointerType>(type));
>-        else if (is<AST::ArrayReferenceType>(type))
>-            visit(downcast<AST::ArrayReferenceType>(type));
>+        if (is<AST::TypeReference>(unnamedType))
>+            visit(downcast<AST::TypeReference>(unnamedType));
>+        else if (is<AST::PointerType>(unnamedType))
>+            visit(downcast<AST::PointerType>(unnamedType));
>+        else if (is<AST::ArrayReferenceType>(unnamedType))
>+            visit(downcast<AST::ArrayReferenceType>(unnamedType));
>         else {
>-            ASSERT(is<AST::ArrayType>(type));
>-            visit(downcast<AST::ArrayType>(type));
>+            ASSERT(is<AST::ArrayType>(unnamedType));
>+            visit(downcast<AST::ArrayType>(unnamedType));
>+        }
>+    }
>+
>+    void visitNamedType(AST::NamedType& namedType)
>+    {
>+        if (is<AST::TypeDefinition>(namedType))
>+            visit(downcast<AST::TypeDefinition>(namedType));
>+        else if (is<AST::StructureDefinition>(namedType))
>+            visit(downcast<AST::StructureDefinition>(namedType));
>+        else if (is<AST::EnumerationDefinition>(namedType))
>+            visit(downcast<AST::EnumerationDefinition>(namedType));
>+        else {
>+            ASSERT(is<AST::NativeTypeDeclaration>(namedType));
>+            visit(downcast<AST::NativeTypeDeclaration>(namedType));
>         }
>     }
> 
>     virtual void visit(AST::TypeDefinition& typeDefinition)
>     {
>-        visitType(typeDefinition.type());
>+        visitUnnamedType(typeDefinition.type());
>     }
> 
>     virtual void visit(AST::StructureDefinition& structureDefinition)
>@@ -148,7 +161,7 @@ class Visitor {
> 
>     virtual void visit(AST::EnumerationDefinition& enumerationDefinition)
>     {
>-        visitType(enumerationDefinition.type());
>+        visitUnnamedType(enumerationDefinition.type());
>         for (auto& enumerationMember : enumerationDefinition.enumerationMembers())
>             visit(enumerationMember);
>     }
>@@ -174,6 +187,8 @@ class Visitor {
>     {
>         for (auto& typeArgument : typeReference.typeArguments())
>             visit(typeArgument);
>+        if (typeReference.resolvedType() && is<AST::TypeDefinition>(*typeReference.resolvedType()))
>+            visitUnnamedType(downcast<AST::TypeDefinition>(*typeReference.resolvedType()).type());
>     }
> 
>     virtual void visit(AST::PointerType& pointerType)
>@@ -188,12 +203,12 @@ class Visitor {
> 
>     virtual void visit(AST::ArrayType& arrayType)
>     {
>-        visitType(arrayType.type());
>+        visitUnnamedType(arrayType.type());
>     }
> 
>     virtual void visit(AST::StructureElement& structureElement)
>     {
>-        visitType(structureElement.type());
>+        visitUnnamedType(structureElement.type());
>         if (structureElement.semantic())
>             visit(*structureElement.semantic());
>     }
>@@ -207,7 +222,7 @@ class Visitor {
>     virtual void visit(AST::FunctionDeclaration& functionDeclaration)
>     {
>         visit(functionDeclaration.attributeBlock());
>-        visitType(functionDeclaration.type());
>+        visitUnnamedType(functionDeclaration.type());
>         for (auto& parameter : functionDeclaration.parameters())
>             visit(parameter);
>         if (functionDeclaration.semantic())
>@@ -225,7 +240,7 @@ class Visitor {
> 
>     virtual void visit(AST::ReferenceType& referenceType)
>     {
>-        visitType(referenceType.elementType());
>+        visitUnnamedType(referenceType.elementType());
>     }
> 
>     virtual void visit(AST::Semantic& semantic)
>@@ -264,13 +279,6 @@ class Visitor {
>             visit(functionAttribute);
>     }
> 
>-    virtual void visit(AST::Parameter& parameter)
>-    {
>-        visitType(parameter.type());
>-        if (parameter.semantic())
>-            visit(*parameter.semantic());
>-    }
>-
>     virtual void visit(AST::BuiltInSemantic&)
>     {
>     }
>@@ -402,8 +410,10 @@ class Visitor {
>             visit(downcast<AST::MakePointerExpression>(expression));
>         else if (is<AST::NullLiteral>(expression))
>             visit(downcast<AST::NullLiteral>(expression));
>-        else if (is<AST::PropertyAccessExpression>(expression))
>-            visit(downcast<AST::PropertyAccessExpression>(expression));
>+        else if (is<AST::DotExpression>(expression))
>+            visit(downcast<AST::DotExpression>(expression));
>+        else if (is<AST::IndexExpression>(expression))
>+            visit(downcast<AST::IndexExpression>(expression));
>         else if (is<AST::ReadModifyWriteExpression>(expression))
>             visit(downcast<AST::ReadModifyWriteExpression>(expression));
>         else if (is<AST::TernaryExpression>(expression))
>@@ -416,6 +426,22 @@ class Visitor {
>         }
>     }
> 
>+    virtual void visit(AST::DotExpression& dotExpression)
>+    {
>+        visit(static_cast<AST::PropertyAccessExpression&>(dotExpression));
>+    }
>+
>+    virtual void visit(AST::IndexExpression& indexExpression)
>+    {
>+        visit(indexExpression.indexExpression());
>+        visit(static_cast<AST::PropertyAccessExpression&>(indexExpression));
>+    }
>+
>+    virtual void visit(AST::PropertyAccessExpression& expression)
>+    {
>+        visit(expression.base());
>+    }
>+
>     virtual void visit(AST::EffectfulExpressionStatement& effectfulExpressionStatement)
>     {
>         visit(effectfulExpressionStatement.effectfulExpression());
>@@ -485,7 +511,7 @@ class Visitor {
> 
>     virtual void visit(AST::VariableDeclaration& variableDeclaration)
>     {
>-        visitType(variableDeclaration.type());
>+        visitUnnamedType(variableDeclaration.type());
>         if (variableDeclaration.semantic())
>             visit(*variableDeclaration.semantic());
>         if (variableDeclaration.initializer())
>@@ -536,11 +562,6 @@ class Visitor {
>         visit(makePointerExpression.lValue());
>     }
> 
>-    virtual void visit(AST::PropertyAccessExpression& propertyAccessExpression)
>-    {
>-        visit(propertyAccessExpression.base());
>-    }
>-
>     virtual void visit(AST::ReadModifyWriteExpression& readModifyWriteExpression)
>     {
>         visit(readModifyWriteExpression.lValue());
>@@ -560,10 +581,6 @@ class Visitor {
>     virtual void visit(AST::VariableReference&)
>     {
>     }
>-
>-    virtual void visit(AST::AnonymousVariableDeclaration&)
>-    {
>-    }
> };
> 
> }
>diff --git a/Source/WebCore/Sources.txt b/Source/WebCore/Sources.txt
>index 3c0e3647054..1464eb37b7e 100644
>--- a/Source/WebCore/Sources.txt
>+++ b/Source/WebCore/Sources.txt
>@@ -306,7 +306,7 @@ Modules/webgpu/DOMWindowWebGPU.cpp
> Modules/webgpu/WHLSL/WHLSLLexer.cpp
> Modules/webgpu/WHLSL/WHLSLParser.cpp
> Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>-Modules/webgpu/WHLSL/WHLSLNameResolver.cpp
>+Modules/webgpu/WHLSL/WHLSLIntrinsics.cpp
> Modules/webgpu/WHLSL/AST/WHLSLTypeArgument.cpp
> Modules/webgpu/WebGPU.cpp
> Modules/webgpu/WebGPUAdapter.cpp
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index 07c16ef1775..a0e4e30d18f 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -6403,9 +6403,20 @@
> 		1C24EEA71C72A7B40080F8FC /* JSFontFaceSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JSFontFaceSet.h; path = DerivedSources/WebCore/JSFontFaceSet.h; sourceTree = BUILT_PRODUCTS_DIR; };
> 		1C2649790D7E248A00BD10F2 /* DocumentLoaderMac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DocumentLoaderMac.cpp; sourceTree = "<group>"; };
> 		1C3249101C6D6A3B007EDB32 /* FontVariantBuilder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontVariantBuilder.cpp; sourceTree = "<group>"; };
>+		1C33276C21CEDA42000DC9F2 /* WHLSLEnumerationMemberLiteral.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLEnumerationMemberLiteral.h; sourceTree = "<group>"; };
>+		1C33276E21CEFF74000DC9F2 /* WHLSLResolveOverloadImpl.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLResolveOverloadImpl.h; sourceTree = "<group>"; };
>+		1C33276F21CF0131000DC9F2 /* WHLSLInferTypes.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLInferTypes.h; sourceTree = "<group>"; };
>+		1C33277121CF0BE1000DC9F2 /* WHLSLNamedType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLNamedType.h; sourceTree = "<group>"; };
>+		1C33277221CF0D2E000DC9F2 /* WHLSLUnnamedType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLUnnamedType.h; sourceTree = "<group>"; };
>+		1C33277421D5A706000DC9F2 /* WHLSLRecursiveTypeChecker.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLRecursiveTypeChecker.h; sourceTree = "<group>"; };
>+		1C33277521D5B0F8000DC9F2 /* WHLSLCheckDuplicateFunctions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLCheckDuplicateFunctions.h; sourceTree = "<group>"; };
>+		1C33277621D5C07E000DC9F2 /* WHLSLSynthesizeStructureAccessors.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLSynthesizeStructureAccessors.h; sourceTree = "<group>"; };
>+		1C33277721D5CA83000DC9F2 /* WHLSLSynthesizeEnumerationFunctions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLSynthesizeEnumerationFunctions.h; sourceTree = "<group>"; };
>+		1C33277821D5CED4000DC9F2 /* WHLSLSynthesizeArrayOperatorLength.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLSynthesizeArrayOperatorLength.h; sourceTree = "<group>"; };
> 		1C3969CF1B74211E002BCFA7 /* FontCacheCoreText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontCacheCoreText.cpp; sourceTree = "<group>"; };
> 		1C66260E1C6E7CA600AB527C /* FontFace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontFace.cpp; sourceTree = "<group>"; };
> 		1C66260F1C6E7CA600AB527C /* FontFace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FontFace.h; sourceTree = "<group>"; };
>+		1C7CC21D21CDE19800C1FA2C /* WHLSLNameContext.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLNameContext.h; sourceTree = "<group>"; };
> 		1C81B9560E97330800266E07 /* InspectorController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorController.h; sourceTree = "<group>"; };
> 		1C81B9570E97330800266E07 /* InspectorController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InspectorController.cpp; sourceTree = "<group>"; };
> 		1C81B9580E97330800266E07 /* InspectorClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorClient.h; sourceTree = "<group>"; };
>@@ -13214,6 +13225,8 @@
> 		C11A9ECD21403A5C00CFB20A /* SwitchingGPUClient.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SwitchingGPUClient.h; sourceTree = "<group>"; };
> 		C11A9ED22140578B00CFB20A /* SwitchingGPUClient.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = SwitchingGPUClient.cpp; sourceTree = "<group>"; };
> 		C1E1D235203DF15400584665 /* ScreenProperties.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ScreenProperties.h; sourceTree = "<group>"; };
>+		C201334421DAC09500B60C27 /* WHLSLIntrinsics.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLIntrinsics.h; sourceTree = "<group>"; };
>+		C201334621DAEE6E00B60C27 /* WHLSLIntrinsics.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLIntrinsics.cpp; sourceTree = "<group>"; };
> 		C2015C091BE6FE2C00822389 /* FontVariantBuilder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FontVariantBuilder.h; sourceTree = "<group>"; };
> 		C210E91121B4BD1000B7F83D /* WHLSLLexer.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLLexer.cpp; sourceTree = "<group>"; };
> 		C210E91221B4BD1000B7F83D /* WHLSLLexer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLLexer.h; sourceTree = "<group>"; };
>@@ -13245,7 +13258,6 @@
> 		C21BF70C21CD89CC00227979 /* WHLSLExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLExpression.h; sourceTree = "<group>"; };
> 		C21BF70D21CD89CD00227979 /* WHLSLReferenceType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLReferenceType.h; sourceTree = "<group>"; };
> 		C21BF70E21CD89CE00227979 /* WHLSLStageInOutSemantic.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLStageInOutSemantic.h; sourceTree = "<group>"; };
>-		C21BF70F21CD89CF00227979 /* WHLSLAnonymousVariableDeclaration.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLAnonymousVariableDeclaration.h; sourceTree = "<group>"; };
> 		C21BF71021CD89D000227979 /* WHLSLVariableDeclaration.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLVariableDeclaration.h; sourceTree = "<group>"; };
> 		C21BF71121CD89D100227979 /* WHLSLTypeArgument.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLTypeArgument.h; sourceTree = "<group>"; };
> 		C21BF71221CD89D100227979 /* WHLSLStatement.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLStatement.h; sourceTree = "<group>"; };
>@@ -13253,7 +13265,6 @@
> 		C21BF71421CD89D300227979 /* WHLSLVariableDeclarationsStatement.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLVariableDeclarationsStatement.h; sourceTree = "<group>"; };
> 		C21BF71521CD89D400227979 /* WHLSLLogicalNotExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLLogicalNotExpression.h; sourceTree = "<group>"; };
> 		C21BF71621CD89D500227979 /* WHLSLCallExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLCallExpression.h; sourceTree = "<group>"; };
>-		C21BF71721CD89D600227979 /* WHLSLParameter.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLParameter.h; sourceTree = "<group>"; };
> 		C21BF71821CD89D700227979 /* WHLSLDotExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLDotExpression.h; sourceTree = "<group>"; };
> 		C21BF71921CD89D700227979 /* WHLSLSwitchCase.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLSwitchCase.h; sourceTree = "<group>"; };
> 		C21BF71A21CD89D800227979 /* WHLSLBreak.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLBreak.h; sourceTree = "<group>"; };
>@@ -13302,7 +13313,6 @@
> 		C288C72721C8C6EF002DF5CA /* WHLSLVisitor.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLVisitor.h; sourceTree = "<group>"; };
> 		C288C72921C8CA50002DF5CA /* WHLSLPrepare.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLPrepare.cpp; sourceTree = "<group>"; };
> 		C288C72A21C8CA50002DF5CA /* WHLSLPrepare.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLPrepare.h; sourceTree = "<group>"; };
>-		C288C72B21C8CCC2002DF5CA /* WHLSLNameResolver.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLNameResolver.cpp; sourceTree = "<group>"; };
> 		C288C72C21C8CCC2002DF5CA /* WHLSLNameResolver.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLNameResolver.h; sourceTree = "<group>"; };
> 		C288C72D21C991DA002DF5CA /* WHLSLTypeArgument.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLTypeArgument.cpp; sourceTree = "<group>"; };
> 		C2AB0AF41E6B3C6C001348C5 /* FontSelectionAlgorithm.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontSelectionAlgorithm.cpp; sourceTree = "<group>"; };
>@@ -25332,11 +25342,20 @@
> 				C21BF73721CD8A0200227979 /* WHLSLParser.cpp */,
> 				C21BF73821CD8A0300227979 /* WHLSLParser.h */,
> 				C21BF73A21CD8D7000227979 /* WHLSLProgram.h */,
>- 				C288C72721C8C6EF002DF5CA /* WHLSLVisitor.h */,
>- 				C288C72921C8CA50002DF5CA /* WHLSLPrepare.cpp */,
>- 				C288C72A21C8CA50002DF5CA /* WHLSLPrepare.h */,
>- 				C288C72B21C8CCC2002DF5CA /* WHLSLNameResolver.cpp */,
>- 				C288C72C21C8CCC2002DF5CA /* WHLSLNameResolver.h */,
>+				C288C72721C8C6EF002DF5CA /* WHLSLVisitor.h */,
>+				C288C72921C8CA50002DF5CA /* WHLSLPrepare.cpp */,
>+				C288C72A21C8CA50002DF5CA /* WHLSLPrepare.h */,
>+				C288C72C21C8CCC2002DF5CA /* WHLSLNameResolver.h */,
>+				1C7CC21D21CDE19800C1FA2C /* WHLSLNameContext.h */,
>+				1C33276E21CEFF74000DC9F2 /* WHLSLResolveOverloadImpl.h */,
>+				1C33276F21CF0131000DC9F2 /* WHLSLInferTypes.h */,
>+				1C33277421D5A706000DC9F2 /* WHLSLRecursiveTypeChecker.h */,
>+				1C33277521D5B0F8000DC9F2 /* WHLSLCheckDuplicateFunctions.h */,
>+				1C33277621D5C07E000DC9F2 /* WHLSLSynthesizeStructureAccessors.h */,
>+				1C33277721D5CA83000DC9F2 /* WHLSLSynthesizeEnumerationFunctions.h */,
>+				1C33277821D5CED4000DC9F2 /* WHLSLSynthesizeArrayOperatorLength.h */,
>+				C201334421DAC09500B60C27 /* WHLSLIntrinsics.h */,
>+				C201334621DAEE6E00B60C27 /* WHLSLIntrinsics.cpp */,
> 			);
> 			path = WHLSL;
> 			sourceTree = "<group>";
>@@ -25344,7 +25363,6 @@
> 		C21BF6F121CD898D00227979 /* AST */ = {
> 			isa = PBXGroup;
> 			children = (
>-				C21BF70F21CD89CF00227979 /* WHLSLAnonymousVariableDeclaration.h */,
> 				C21BF72521CD89E200227979 /* WHLSLArrayReferenceType.h */,
> 				C21BF70921CD89CA00227979 /* WHLSLArrayType.h */,
> 				C21BF73021CD89ED00227979 /* WHLSLAssignmentExpression.h */,
>@@ -25384,7 +25402,6 @@
> 				C21BF72421CD89E100227979 /* WHLSLNode.h */,
> 				C21BF70721CD89C800227979 /* WHLSLNullLiteral.h */,
> 				C21BF72121CD89DE00227979 /* WHLSLNumThreadsFunctionAttribute.h */,
>-				C21BF71721CD89D600227979 /* WHLSLParameter.h */,
> 				C21BF72F21CD89EC00227979 /* WHLSLPointerType.h */,
> 				C21BF72E21CD89EA00227979 /* WHLSLPropertyAccessExpression.h */,
> 				C21BF70B21CD89CC00227979 /* WHLSLQualifier.h */,
>@@ -25412,7 +25429,10 @@
> 				C21BF71421CD89D300227979 /* WHLSLVariableDeclarationsStatement.h */,
> 				C21BF71321CD89D200227979 /* WHLSLVariableReference.h */,
> 				C21BF70421CD89C600227979 /* WHLSLWhileLoop.h */,
>- 				C288C72D21C991DA002DF5CA /* WHLSLTypeArgument.cpp */,
>+				C288C72D21C991DA002DF5CA /* WHLSLTypeArgument.cpp */,
>+				1C33276C21CEDA42000DC9F2 /* WHLSLEnumerationMemberLiteral.h */,
>+				1C33277121CF0BE1000DC9F2 /* WHLSLNamedType.h */,
>+				1C33277221CF0D2E000DC9F2 /* WHLSLUnnamedType.h */,
> 			);
> 			path = AST;
> 			sourceTree = "<group>";

Actions: View | Formatted Diff | Diff

Attachments on bug 193007: 358021 | 358022 | 358157 | 358164 | 358167 | 358169 | 358883 | 358908 | 358922 | 358928 | 358977