Attachment 359401 Details for Bug 193531 – WIP

[patch] WIP

bug-193531-20190117120740.patch (text/plain), 42.48 KB, created by Myles C. Maxfield on 2019-01-17 12:07:41 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Myles C. Maxfield

Created: 2019-01-17 12:07:41 PST

Size: 42.48 KB

patch

obsolete

>Subversion Revision: 240102
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 2dd9d50fe636288195f458eb51848519ec65a993..e65f6b5e9476820da2ab80272c3997aa04e9772b 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,40 @@
>+2019-01-17  Myles C. Maxfield  <mmaxfield@apple.com>
>+
>+        [WHLSL] Implement Metal code generation
>+        https://bugs.webkit.org/show_bug.cgi?id=193531
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        No new tests (OOPS!).
>+
>+        * Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp: Added.
>+        (WebCore::WHLSL::Metal::BaseTypeNameNode::BaseTypeNameNode):
>+        (WebCore::WHLSL::Metal::BaseTypeNameNode::isArrayTypeNameNode const):
>+        (WebCore::WHLSL::Metal::BaseTypeNameNode::isArrayReferenceTypeNameNode const):
>+        (WebCore::WHLSL::Metal::BaseTypeNameNode::isPointerTypeNameNode const):
>+        (WebCore::WHLSL::Metal::BaseTypeNameNode::isReferenceTypeNameNode const):
>+        (WebCore::WHLSL::Metal::ArrayTypeNameNode::ArrayTypeNameNode):
>+        (WebCore::WHLSL::Metal::ArrayTypeNameNode::numElements const):
>+        (WebCore::WHLSL::Metal::ArrayTypeNameNode::children):
>+        (WebCore::WHLSL::Metal::ArrayTypeNameNode::append):
>+        (WebCore::WHLSL::Metal::ArrayReferenceTypeNameNode::ArrayReferenceTypeNameNode):
>+        (WebCore::WHLSL::Metal::ArrayReferenceTypeNameNode::addressSpace const):
>+        (WebCore::WHLSL::Metal::ArrayReferenceTypeNameNode::children):
>+        (WebCore::WHLSL::Metal::ArrayReferenceTypeNameNode::append):
>+        (WebCore::WHLSL::Metal::PointerTypeNameNode::PointerTypeNameNode):
>+        (WebCore::WHLSL::Metal::PointerTypeNameNode::addressSpace const):
>+        (WebCore::WHLSL::Metal::PointerTypeNameNode::children):
>+        (WebCore::WHLSL::Metal::PointerTypeNameNode::append):
>+        (WebCore::WHLSL::Metal::ReferenceTypeNameNode::ReferenceTypeNameNode):
>+        (WebCore::WHLSL::Metal::ReferenceTypeNameNode::namedType const):
>+        (WebCore::WHLSL::Metal::TypeNamer::generateNextName):
>+        (WebCore::WHLSL::Metal::TypeNamer::build):
>+        (WebCore::WHLSL::Metal::TypeNamer::insert):
>+        (WebCore::WHLSL::Metal::typeNames):
>+        * Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h: Added.
>+        * Sources.txt:
>+        * WebCore.xcodeproj/project.pbxproj:
>+
> 2019-01-16  Justin Fan  <justin_fan@apple.com>
> 
>         [WebGPU] Update vertex-buffer-triangle-strip.html to actually use vertex buffer
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..bd0d641006cd906d63110bc0d3bbf4325ada4557
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp
>@@ -0,0 +1,418 @@
>+/*
>+ * Copyright (C) 2019 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.
>+ */
>+
>+#include "config.h"
>+#include "WHLSLTypeNamer.h"
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLAddressSpace.h"
>+#include "WHLSLArrayReferenceType.h"
>+#include "WHLSLArrayType.h"
>+#include "WHLSLEnumerationDefinition.h"
>+#include "WHLSLEnumerationMember.h"
>+#include "WHLSLNativeTypeDeclaration.h"
>+#include "WHLSLPointerType.h"
>+#include "WHLSLStructureDefinition.h"
>+#include "WHLSLTypeDefinition.h"
>+#include "WHLSLTypeReference.h"
>+#include "WHLSLVisitor.h"
>+#include <algorithm>
>+#include <functional>
>+#include <wtf/HashMap.h>
>+#include <wtf/Optional.h>
>+#include <wtf/UniqueRef.h>
>+#include <wtf/Vector.h>
>+#include <wtf/text/StringBuilder.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+namespace Metal {
>+
>+class BaseTypeNameNode {
>+public:
>+    BaseTypeNameNode(String&& mangledName)
>+        : m_mangledName(mangledName)
>+    {
>+    }
>+    virtual ~BaseTypeNameNode() = default;
>+    virtual bool isArrayTypeNameNode() const { return false; }
>+    virtual bool isArrayReferenceTypeNameNode() const { return false; }
>+    virtual bool isPointerTypeNameNode() const { return false; }
>+    virtual bool isReferenceTypeNameNode() const { return false; }
>+    Vector<UniqueRef<BaseTypeNameNode>>& children() { return m_children; }
>+    void append(UniqueRef<BaseTypeNameNode>&& child)
>+    {
>+        m_children.append(WTFMove(child));
>+    }
>+    const String& mangledName() const { return m_mangledName; }
>+
>+private:
>+    Vector<UniqueRef<BaseTypeNameNode>> m_children;
>+    String m_mangledName;
>+};
>+
>+class ArrayTypeNameNode : public BaseTypeNameNode {
>+public:
>+    ArrayTypeNameNode(String&& mangledName, unsigned numElements)
>+        : BaseTypeNameNode(WTFMove(mangledName))
>+        , m_numElements(numElements)
>+    {
>+    }
>+    virtual ~ArrayTypeNameNode() = default;
>+    bool isArrayTypeNameNode() const override { return true; }
>+    unsigned numElements() const { return m_numElements; }
>+
>+private:
>+    unsigned m_numElements;
>+};
>+
>+class ArrayReferenceTypeNameNode : public BaseTypeNameNode {
>+public:
>+    ArrayReferenceTypeNameNode(String&& mangledName, AST::AddressSpace addressSpace)
>+        : BaseTypeNameNode(WTFMove(mangledName))
>+        , m_addressSpace(addressSpace)
>+    {
>+    }
>+    virtual ~ArrayReferenceTypeNameNode() = default;
>+    bool isArrayReferenceTypeNameNode() const override { return true; }
>+    AST::AddressSpace addressSpace() const { return m_addressSpace; }
>+
>+private:
>+    AST::AddressSpace m_addressSpace;
>+};
>+
>+class PointerTypeNameNode : public BaseTypeNameNode {
>+public:
>+    PointerTypeNameNode(String&& mangledName, AST::AddressSpace addressSpace)
>+        : BaseTypeNameNode(WTFMove(mangledName))
>+        , m_addressSpace(addressSpace)
>+    {
>+    }
>+    virtual ~PointerTypeNameNode() = default;
>+    bool isPointerTypeNameNode() const override { return true; }
>+    AST::AddressSpace addressSpace() const { return m_addressSpace; }
>+
>+private:
>+    AST::AddressSpace m_addressSpace;
>+};
>+
>+class ReferenceTypeNameNode : public BaseTypeNameNode {
>+public:
>+    ReferenceTypeNameNode(String&& mangledName, AST::NamedType& namedType)
>+        : BaseTypeNameNode(WTFMove(mangledName))
>+        , m_namedType(namedType)
>+    {
>+    }
>+    virtual ~ReferenceTypeNameNode() = default;
>+    bool isReferenceTypeNameNode() const override { return true; }
>+    const AST::NamedType& namedType() const { return m_namedType; }
>+
>+private:
>+    AST::NamedType& m_namedType;
>+};
>+
>+}
>+
>+}
>+
>+}
>+
>+#define SPECIALIZE_TYPE_TRAITS_WHLSL_BASE_TYPE_NAMED_NODE(ToValueTypeName, predicate) \
>+SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::WHLSL::Metal::ToValueTypeName) \
>+    static bool isType(const WebCore::WHLSL::Metal::BaseTypeNameNode& type) { return type.predicate; } \
>+SPECIALIZE_TYPE_TRAITS_END()
>+
>+SPECIALIZE_TYPE_TRAITS_WHLSL_BASE_TYPE_NAMED_NODE(ArrayTypeNameNode, isArrayTypeNameNode())
>+
>+SPECIALIZE_TYPE_TRAITS_WHLSL_BASE_TYPE_NAMED_NODE(ArrayReferenceTypeNameNode, isArrayReferenceTypeNameNode())
>+
>+SPECIALIZE_TYPE_TRAITS_WHLSL_BASE_TYPE_NAMED_NODE(PointerTypeNameNode, isPointerTypeNameNode())
>+
>+SPECIALIZE_TYPE_TRAITS_WHLSL_BASE_TYPE_NAMED_NODE(ReferenceTypeNameNode, isReferenceTypeNameNode())
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+namespace Metal {
>+
>+TypeNamer::TypeNamer(Program& program)
>+    : m_program(program)
>+{
>+}
>+
>+TypeNamer::~TypeNamer() = default;
>+
>+void TypeNamer::visit(AST::UnnamedType& unnamedType)
>+{
>+    insert(unnamedType, m_trie);
>+}
>+
>+void TypeNamer::visit(AST::EnumerationDefinition& enumerationDefinition)
>+{
>+    auto addResult = m_namedTypeMapping.add(&enumerationDefinition, generateNextTypeName());
>+    ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    for (auto& enumerationMember : enumerationDefinition.enumerationMembers()) {
>+        auto addResult = m_enumerationMemberMapping.add(&static_cast<AST::EnumerationMember&>(enumerationMember), generateNextEnumerationMemberName());
>+        ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    }
>+    Visitor::visit(enumerationDefinition);
>+}
>+
>+void TypeNamer::visit(AST::NativeTypeDeclaration&)
>+{
>+    // Native type declarations already have names, and are already declared in Metal.
>+}
>+
>+static Vector<UniqueRef<BaseTypeNameNode>>::iterator findInVector(AST::UnnamedType& unnamedType, Vector<UniqueRef<BaseTypeNameNode>>& types)
>+{
>+    return std::find_if(types.begin(), types.end(), [&](BaseTypeNameNode& baseTypeNameNode) -> bool {
>+        if (is<AST::TypeReference>(unnamedType) && is<ReferenceTypeNameNode>(baseTypeNameNode)) {
>+            auto* resolvedType = downcast<AST::TypeReference>(unnamedType).resolvedType();
>+            ASSERT(resolvedType);
>+            return resolvedType == &downcast<ReferenceTypeNameNode>(baseTypeNameNode).namedType();
>+        }
>+        if (is<AST::PointerType>(unnamedType) && is<PointerTypeNameNode>(baseTypeNameNode))
>+            return downcast<AST::PointerType>(unnamedType).addressSpace() == downcast<PointerTypeNameNode>(baseTypeNameNode).addressSpace();
>+        if (is<AST::ArrayReferenceType>(unnamedType) && is<ArrayReferenceTypeNameNode>(baseTypeNameNode))
>+            return downcast<AST::ArrayReferenceType>(unnamedType).addressSpace() == downcast<ArrayReferenceTypeNameNode>(baseTypeNameNode).addressSpace();
>+        if (is<AST::ArrayType>(unnamedType) && is<ArrayTypeNameNode>(baseTypeNameNode))
>+            return downcast<AST::ArrayType>(unnamedType).numElements() == downcast<ArrayTypeNameNode>(baseTypeNameNode).numElements();
>+        return false;
>+    });
>+}
>+
>+static BaseTypeNameNode& find(AST::UnnamedType& unnamedType, Vector<UniqueRef<BaseTypeNameNode>>& types)
>+{
>+    auto& vectorToSearch = ([&]() -> Vector<UniqueRef<BaseTypeNameNode>>& {
>+        if (is<AST::TypeReference>(unnamedType))
>+            return types;
>+        if (is<AST::PointerType>(unnamedType))
>+            return find(downcast<AST::PointerType>(unnamedType).elementType(), types).children();
>+        if (is<AST::ArrayReferenceType>(unnamedType))
>+            return find(downcast<AST::ArrayReferenceType>(unnamedType).elementType(), types).children();
>+        ASSERT(is<AST::ArrayType>(unnamedType));
>+        return find(downcast<AST::ArrayType>(unnamedType).type(), types).children();
>+    })();
>+    auto iterator = findInVector(unnamedType, vectorToSearch);
>+    ASSERT(iterator != types.end());
>+    return *iterator;
>+}
>+
>+void TypeNamer::visit(AST::StructureDefinition& structureDefinition)
>+{
>+    {
>+        auto addResult = m_namedTypeMapping.add(&structureDefinition, generateNextTypeName());
>+        ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    }
>+    Visitor::visit(structureDefinition);
>+    {
>+        Vector<std::reference_wrapper<BaseTypeNameNode>> neighbors;
>+        for (auto& structureElement : structureDefinition.structureElements())
>+            neighbors.append(find(structureElement.type(), m_trie));
>+        auto addResult = m_dependencyGraph.add(&structureDefinition, WTFMove(neighbors));
>+        ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    }
>+}
>+
>+void TypeNamer::visit(AST::TypeDefinition& typeDefinition)
>+{
>+    {
>+        auto addResult = m_namedTypeMapping.add(&typeDefinition, generateNextTypeName());
>+        ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    }
>+    Visitor::visit(typeDefinition);
>+    {
>+        Vector<std::reference_wrapper<BaseTypeNameNode>> neighbors = { find(typeDefinition.type(), m_trie) };
>+        auto addResult = m_dependencyGraph.add(&typeDefinition, WTFMove(neighbors));
>+        ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    }
>+}
>+
>+String TypeNamer::mangledNameForType(AST::NativeTypeDeclaration&)
>+{
>+    // FIXME: Implement this.
>+}
>+
>+UniqueRef<BaseTypeNameNode> TypeNamer::createNameNode(AST::UnnamedType& unnamedType)
>+{
>+    if (is<AST::TypeReference>(unnamedType)) {
>+        auto& typeReference = downcast<AST::TypeReference>(unnamedType);
>+        ASSERT(typeReference.resolvedType());
>+        return makeUniqueRef<ReferenceTypeNameNode>(generateNextTypeName(), *typeReference.resolvedType());
>+    }
>+    if (is<AST::PointerType>(unnamedType)) {
>+        auto& pointerType = downcast<AST::PointerType>(unnamedType);
>+        return makeUniqueRef<PointerTypeNameNode>(generateNextTypeName(), pointerType.addressSpace());
>+    }
>+    if (is<AST::ArrayReferenceType>(unnamedType)) {
>+        auto& arrayReferenceType = downcast<AST::ArrayReferenceType>(unnamedType);
>+        return makeUniqueRef<ArrayReferenceTypeNameNode>(generateNextTypeName(), arrayReferenceType.addressSpace());
>+    }
>+    ASSERT(is<AST::ArrayType>(unnamedType));
>+    auto& arrayType = downcast<AST::ArrayType>(unnamedType);
>+    return makeUniqueRef<ArrayTypeNameNode>(generateNextTypeName(), arrayType.numElements());
>+}
>+
>+size_t TypeNamer::insert(AST::UnnamedType& unnamedType, Vector<UniqueRef<BaseTypeNameNode>>& types)
>+{
>+    auto& vectorToInsertInto = ([&]() -> Vector<UniqueRef<BaseTypeNameNode>>& {
>+        if (is<AST::TypeReference>(unnamedType))
>+            return types;
>+        if (is<AST::PointerType>(unnamedType))
>+            return types[insert(downcast<AST::PointerType>(unnamedType).elementType(), types)]->children();
>+        if (is<AST::ArrayReferenceType>(unnamedType))
>+            return types[insert(downcast<AST::ArrayReferenceType>(unnamedType).elementType(), types)]->children();
>+        ASSERT(is<AST::ArrayType>(unnamedType));
>+        return types[insert(downcast<AST::ArrayType>(unnamedType).type(), types)]->children();
>+    })();
>+    auto iterator = findInVector(unnamedType, vectorToInsertInto);
>+    if (iterator == vectorToInsertInto.end()) {
>+        auto result = createNameNode(unnamedType);
>+        {
>+            auto addResult = m_unnamedTypeMapping.add(&unnamedType, &result);
>+            ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+        }
>+        vectorToInsertInto.append(WTFMove(result));
>+        return vectorToInsertInto.size() - 1;
>+    }
>+    auto addResult = m_unnamedTypeMapping.add(&unnamedType, &*iterator);
>+    ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    return iterator - vectorToInsertInto.begin();
>+}
>+
>+class MetalTypeDeclarationWriter : public Visitor {
>+public:
>+    MetalTypeDeclarationWriter(std::function<String(AST::NamedType&)>&& mangledNameForNamedType, std::function<String(AST::UnnamedType&)>&& mangledNameForUnnamedType, std::function<String(AST::EnumerationMember&)>&& mangledNameForEnumerationMember, std::function<String(AST::StructureElement&)>&& mangledNameForStructureElement)
>+        : m_mangledNameForNamedType(WTFMove(mangledNameForNamedType))
>+        , m_mangledNameForUnnamedType(WTFMove(mangledNameForUnnamedType))
>+        , m_mangledNameForEnumerationMember(WTFMove(mangledNameForEnumerationMember))
>+        , m_mangledNameForStructureElement(WTFMove(mangledNameForStructureElement))
>+    {
>+    }
>+
>+    String toString() { return m_stringBuilder.toString(); }
>+
>+private:
>+    void visit(AST::EnumerationDefinition& enumerationDefinition)
>+    {
>+        m_stringBuilder.append("enum class ");
>+        m_stringBuilder.append(m_mangledNameForNamedType(enumerationDefinition));
>+        m_stringBuilder.append(" : ");
>+        auto& baseType = enumerationDefinition.type().unifyNode();
>+        ASSERT(is<AST::NamedType>(baseType));
>+        m_stringBuilder.append(m_mangledNameForNamedType(downcast<AST::NamedType>(baseType)));
>+        m_stringBuilder.append(" {\n");
>+        for (auto& enumerationMember : enumerationDefinition.enumerationMembers()) {
>+            m_stringBuilder.append(m_mangledNameForEnumerationMember(enumerationMember));
>+            m_stringBuilder.append(",\n");
>+        }
>+        m_stringBuilder.append("}\n");
>+    }
>+
>+    void visit(AST::StructureDefinition& structureDefinition)
>+    {
>+        m_stringBuilder.append("struct ");
>+        m_stringBuilder.append(m_mangledNameForNamedType(structureDefinition));
>+        m_stringBuilder.append(" {\n");
>+        for (auto& structureElement : structureDefinition.structureElements()) {
>+            m_stringBuilder.append(m_mangledNameForUnnamedType(structureElement.type()));
>+            m_stringBuilder.append(" ");
>+            m_stringBuilder.append(m_mangledNameForStructureElement(structureElement));
>+            m_stringBuilder.append(";\n");
>+        }
>+        m_stringBuilder.append("}\n");
>+    }
>+
>+    std::function<String(AST::NamedType&)> m_mangledNameForNamedType;
>+    std::function<String(AST::UnnamedType&)> m_mangledNameForUnnamedType;
>+    std::function<String(AST::EnumerationMember&)>&& m_mangledNameForEnumerationMember;
>+    std::function<String(AST::StructureElement&)>&& m_mangledNameForStructureElement;
>+    StringBuilder m_stringBuilder;
>+};
>+
>+String TypeNamer::metalTypeDefinitions()
>+{
>+    MetalTypeDeclarationWriter metalTypeDeclarationWriter([&](AST::NamedType& namedType) -> String {
>+        return mangledNameForType(namedType);
>+    }, [&](AST::UnnamedType& unnamedType) -> String {
>+        return mangledNameForType(unnamedType);
>+    }, [&](AST::EnumerationMember& enumerationMember) -> String {
>+        return mangledNameForEnumerationMember(enumerationMember);
>+    }, [&](AST::StructureElement& structureElement) -> String {
>+        return mangledNameForStructureElement(structureElement);
>+    });
>+    metalTypeDeclarationWriter.Visitor::visit(m_program);
>+    return metalTypeDeclarationWriter.toString();
>+}
>+
>+String TypeNamer::mangledNameForType(AST::UnnamedType& unnamedType)
>+{
>+    return find(unnamedType, m_trie).mangledName();
>+}
>+
>+String TypeNamer::mangledNameForType(AST::NamedType& namedType)
>+{
>+    if (is<AST::NativeTypeDeclaration>(namedType))
>+        return mangledNameForType(downcast<AST::NativeTypeDeclaration>(namedType));
>+    auto iterator = m_namedTypeMapping.find(&namedType);
>+    ASSERT(iterator != m_namedTypeMapping.end());
>+    return iterator->value;
>+}
>+
>+
>+String TypeNamer::mangledNameForEnumerationMember(AST::EnumerationMember& enumerationMember)
>+{
>+    auto iterator = m_enumerationMemberMapping.find(&enumerationMember);
>+    ASSERT(iterator != m_enumerationMemberMapping.end());
>+    return iterator->value;
>+}
>+
>+String TypeNamer::mangledNameForStructureElement(AST::StructureElement& structureElement)
>+{
>+    auto iterator = m_structureElementMapping.find(&structureElement);
>+    ASSERT(iterator != m_structureElementMapping.end());
>+    return iterator->value;
>+}
>+
>+void typeNames(Program& program)
>+{
>+    TypeNamer typeNamer(program);
>+    typeNamer.Visitor::visit(program);
>+    StringBuilder stringBuilder;
>+    stringBuilder.append(typeNamer.metalTypeDefinitions());
>+    // FIXME: Do something with the result.
>+}
>+
>+}
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..189847589de48ea05c1de0ae6f632077c28682c7
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h
>@@ -0,0 +1,116 @@
>+/*
>+ * Copyright (C) 2019 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/text/StringConcatenate.h>
>+#include <wtf/text/StringConcatenateNumbers.h>
>+#include <wtf/text/WTFString.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+namespace AST {
>+
>+class EnumerationDefinition;
>+class EnumerationMember;
>+class NamedType;
>+class NativeTypeDeclaration;
>+class StructureDefinition;
>+class TypeDefinition;
>+class UnnamedType;
>+
>+}
>+
>+class Program;
>+
>+namespace Metal {
>+
>+class BaseTypeNameNode;
>+
>+class TypeNamer : public Visitor {
>+public:
>+    TypeNamer(Program&);
>+    virtual ~TypeNamer();
>+
>+    String metalTypeDefinitions();
>+
>+    String mangledNameForType(AST::UnnamedType&);
>+    String mangledNameForType(AST::NamedType&);
>+    String mangledNameForEnumerationMember(AST::EnumerationMember&);
>+    String mangledNameForStructureElement(AST::StructureElement&);
>+
>+private:
>+    void visit(AST::UnnamedType&) override;
>+    void visit(AST::EnumerationDefinition&) override;
>+    void visit(AST::NativeTypeDeclaration&) override;
>+    void visit(AST::StructureDefinition&) override;
>+    void visit(AST::TypeDefinition&) override;
>+
>+    String generateNextTypeName()
>+    {
>+        return makeString("type", m_typeCount++);
>+    }
>+
>+    String generateNextEnumerationMemberName()
>+    {
>+        return makeString("enumerationMember", m_enumerationMemberCount++);
>+    }
>+
>+    String generateNextStructureElementName()
>+    {
>+        return makeString("structureElement", m_structureElementCount++);
>+    }
>+
>+    String mangledNameForType(AST::NativeTypeDeclaration&);
>+
>+    UniqueRef<BaseTypeNameNode> createNameNode(AST::UnnamedType&);
>+    size_t insert(AST::UnnamedType&, Vector<UniqueRef<BaseTypeNameNode>>&);
>+
>+    Program& m_program;
>+    Vector<UniqueRef<BaseTypeNameNode>> m_trie;
>+    HashMap<AST::UnnamedType*, BaseTypeNameNode*> m_unnamedTypeMapping;
>+    HashMap<AST::NamedType*, String> m_namedTypeMapping;
>+    HashMap<AST::NamedType*, Vector<std::reference_wrapper<BaseTypeNameNode>>> m_dependencyGraph;
>+    HashMap<AST::EnumerationMember*, String> m_enumerationMemberMapping;
>+    HashMap<AST::StructureElement*, String> m_structureElementMapping;
>+    unsigned m_typeCount { 0 };
>+    unsigned m_enumerationMemberCount { 0 };
>+    unsigned m_structureElementCount { 0 };
>+};
>+
>+void typeNames(Program&);
>+
>+}
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>index 60b0efeecac2463e51a8ec123dccf7a20a46f9e6..3c7e89302335867bfc71a59f4c8cc5f7e5ef549d 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>@@ -612,16 +612,12 @@ void Checker::visit(AST::EnumerationDefinition& enumerationDefinition)
>     auto* baseType = ([&]() -> AST::NativeTypeDeclaration* {
>         checkErrorAndVisit(enumerationDefinition.type());
>         auto& baseType = enumerationDefinition.type().unifyNode();
>-        if (!is<AST::UnnamedType>(baseType))
>+        if (!is<AST::NamedType>(baseType))
>             return nullptr;
>-        auto& unnamedBase = downcast<AST::UnnamedType>(baseType);
>-        if (!is<AST::TypeReference>(unnamedBase))
>+        auto& namedType = downcast<AST::NamedType>(baseType);
>+        if (!is<AST::NativeTypeDeclaration>(namedType))
>             return nullptr;
>-        auto& typeReferenceBase = downcast<AST::TypeReference>(unnamedBase);
>-        ASSERT(typeReferenceBase.resolvedType());
>-        if (!is<AST::NativeTypeDeclaration>(*typeReferenceBase.resolvedType()))
>-            return nullptr;
>-        auto& nativeTypeDeclaration = downcast<AST::NativeTypeDeclaration>(*typeReferenceBase.resolvedType());
>+        auto& nativeTypeDeclaration = downcast<AST::NativeTypeDeclaration>(namedType);
>         if (!nativeTypeDeclaration.isInt())
>             return nullptr;
>         return &nativeTypeDeclaration;
>diff --git a/Source/WebCore/Sources.txt b/Source/WebCore/Sources.txt
>index b6124192ce94452f6d1fe4bbf309fcdac41b472a..7b41ebe1b59715505951d2c7a2d58a563b95be26 100644
>--- a/Source/WebCore/Sources.txt
>+++ b/Source/WebCore/Sources.txt
>@@ -326,6 +326,7 @@ Modules/webgpu/WHLSL/WHLSLVisitor.cpp
> Modules/webgpu/WHLSL/WHLSLLiteralTypeChecker.cpp
> Modules/webgpu/WHLSL/WHLSLHighZombieFinder.cpp
> Modules/webgpu/WHLSL/WHLSLLoopChecker.cpp
>+Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp
> Modules/webgpu/WHLSL/WHLSLFunctionStageChecker.cpp
> Modules/webgpu/WHLSL/AST/WHLSLTypeArgument.cpp
> Modules/webgpu/WHLSL/AST/WHLSLBuiltInSemantic.cpp
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index c498fa8a2bfefd5c7903115bf23708966f924115..4f998232a993028a6b20d0e27fd521dda8a097b2 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -6427,17 +6427,16 @@
> 		1C840B9A21EC400900D0500D /* WHLSLGatherEntryPointItems.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLGatherEntryPointItems.h; sourceTree = "<group>"; };
> 		1C840B9B21EC400900D0500D /* WHLSLChecker.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLChecker.cpp; sourceTree = "<group>"; };
> 		1C904DF90BA9D2C80081E9D0 /* Version.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Version.xcconfig; sourceTree = "<group>"; };
>-		1CA0C2E421EED12A00A11860 /* WHLSLFunctionStageChecker.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLFunctionStageChecker.cpp; sourceTree = "<group>"; };
>-		1CA0C2E521EED12A00A11860 /* WHLSLFunctionStageChecker.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLFunctionStageChecker.h; sourceTree = "<group>"; };
>+		1C9AE5CA21ED9DF50069D5F2 /* WHLSLHighZombieFinder.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLHighZombieFinder.cpp; sourceTree = "<group>"; };
>+		1C9AE5CB21ED9DF50069D5F2 /* WHLSLHighZombieFinder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLHighZombieFinder.h; sourceTree = "<group>"; };
> 		1CA0C2DE21EEB5F400A11860 /* WHLSLRecursionChecker.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLRecursionChecker.h; sourceTree = "<group>"; };
> 		1CA0C2E021EEB5F500A11860 /* WHLSLRecursionChecker.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLRecursionChecker.cpp; sourceTree = "<group>"; };
>+		1CA0C2E421EED12A00A11860 /* WHLSLFunctionStageChecker.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLFunctionStageChecker.cpp; sourceTree = "<group>"; };
>+		1CA0C2E521EED12A00A11860 /* WHLSLFunctionStageChecker.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLFunctionStageChecker.h; sourceTree = "<group>"; };
> 		1CA0C2EA21EED6F500A11860 /* WHLSLLiteralTypeChecker.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLLiteralTypeChecker.h; sourceTree = "<group>"; };
> 		1CA0C2EC21EED6F600A11860 /* WHLSLLiteralTypeChecker.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLLiteralTypeChecker.cpp; sourceTree = "<group>"; };
>-		1C9AE5CA21ED9DF50069D5F2 /* WHLSLHighZombieFinder.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLHighZombieFinder.cpp; sourceTree = "<group>"; };
>-		1C9AE5CB21ED9DF50069D5F2 /* WHLSLHighZombieFinder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLHighZombieFinder.h; sourceTree = "<group>"; };
> 		1CA0C2F421EEDAD000A11860 /* WHLSLLoopChecker.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLLoopChecker.cpp; sourceTree = "<group>"; };
> 		1CA0C2F521EEDAD100A11860 /* WHLSLLoopChecker.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLLoopChecker.h; sourceTree = "<group>"; };
>-		1CA0C2F621EEDAD200A11860 /* AST */ = {isa = PBXFileReference; lastKnownFileType = folder; path = AST; sourceTree = "<group>"; };
> 		1CA19E030DC255950065A994 /* EventLoopMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = EventLoopMac.mm; sourceTree = "<group>"; };
> 		1CA19E150DC255CA0065A994 /* EventLoop.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EventLoop.h; sourceTree = "<group>"; };
> 		1CAF347E0A6C405200ABE06E /* WebScriptObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebScriptObject.h; sourceTree = "<group>"; };
>@@ -13387,6 +13386,8 @@
> 		C2458E611FE8979E00594759 /* FontCacheCoreText.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FontCacheCoreText.h; sourceTree = "<group>"; };
> 		C26017A11C72DC9900F74A16 /* CSSFontFaceSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontFaceSet.cpp; sourceTree = "<group>"; };
> 		C26017A21C72DC9900F74A16 /* CSSFontFaceSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontFaceSet.h; sourceTree = "<group>"; };
>+		C26D2C7021F05D5500497899 /* WHLSLTypeNamer.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLTypeNamer.cpp; sourceTree = "<group>"; };
>+		C26D2C7121F05D5500497899 /* WHLSLTypeNamer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLTypeNamer.h; sourceTree = "<group>"; };
> 		C280833C1C6DB194001451B6 /* FontFace.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = FontFace.idl; sourceTree = "<group>"; };
> 		C280833D1C6DC22C001451B6 /* JSFontFace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JSFontFace.cpp; path = DerivedSources/WebCore/JSFontFace.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
> 		C280833E1C6DC22C001451B6 /* JSFontFace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JSFontFace.h; path = DerivedSources/WebCore/JSFontFace.h; sourceTree = BUILT_PRODUCTS_DIR; };
>@@ -17032,6 +17033,100 @@
> 			tabWidth = 8;
> 			usesTabs = 0;
> 		};
>+		1CA0C2F621EEDAD200A11860 /* AST */ = {
>+			isa = PBXGroup;
>+			children = (
>+				1C840B9021EC30F900D0500D /* WHLSLAddressSpace.h */,
>+				C21BF72521CD89E200227979 /* WHLSLArrayReferenceType.h */,
>+				C21BF70921CD89CA00227979 /* WHLSLArrayType.h */,
>+				C21BF73021CD89ED00227979 /* WHLSLAssignmentExpression.h */,
>+				C21BF70A21CD89CB00227979 /* WHLSLBaseFunctionAttribute.h */,
>+				C21BF6FA21CD89BE00227979 /* WHLSLBaseSemantic.h */,
>+				C21BF71E21CD89DC00227979 /* WHLSLBlock.h */,
>+				C21BF6F621CD89B700227979 /* WHLSLBooleanLiteral.h */,
>+				C21BF71A21CD89D800227979 /* WHLSLBreak.h */,
>+				C2138A1321DDECD300F516BA /* WHLSLBuiltInSemantic.cpp */,
>+				C21BF72221CD89DF00227979 /* WHLSLBuiltInSemantic.h */,
>+				C21BF71621CD89D500227979 /* WHLSLCallExpression.h */,
>+				C21BF70621CD89C700227979 /* WHLSLCommaExpression.h */,
>+				C21BF73321CD89F000227979 /* WHLSLConstantExpression.h */,
>+				C21BF6F521CD89B500227979 /* WHLSLContinue.h */,
>+				C21BF70121CD89C400227979 /* WHLSLDereferenceExpression.h */,
>+				C21BF71821CD89D700227979 /* WHLSLDotExpression.h */,
>+				C21BF6FB21CD89BE00227979 /* WHLSLDoWhileLoop.h */,
>+				C21BF72821CD89E500227979 /* WHLSLEffectfulExpressionStatement.h */,
>+				1C840B7D21EBE0B800D0500D /* WHLSLEntryPointType.h */,
>+				C21BF72021CD89DD00227979 /* WHLSLEnumerationDefinition.h */,
>+				C21BF72621CD89E300227979 /* WHLSLEnumerationMember.h */,
>+				C21BF70221CD89C400227979 /* WHLSLEnumerationMemberLiteral.h */,
>+				C21BF70C21CD89CC00227979 /* WHLSLExpression.h */,
>+				C21BF70021CD89C200227979 /* WHLSLFallthrough.h */,
>+				C21BF73521CD89F200227979 /* WHLSLFloatLiteral.h */,
>+				1CB69B3821DF03E1006E846A /* WHLSLFloatLiteralType.cpp */,
>+				1CB69B3421DED63A006E846A /* WHLSLFloatLiteralType.h */,
>+				C21BF73421CD89F100227979 /* WHLSLForLoop.h */,
>+				C21BF70521CD89C700227979 /* WHLSLFunctionAttribute.h */,
>+				C21BF6FD21CD89C000227979 /* WHLSLFunctionDeclaration.h */,
>+				C21BF6F421CD89B300227979 /* WHLSLFunctionDefinition.h */,
>+				C21BF6FF21CD89C200227979 /* WHLSLIfStatement.h */,
>+				C21BF6F721CD89B900227979 /* WHLSLIndexExpression.h */,
>+				C20F4F6621DFF2360070C45A /* WHLSLIntegerLiteral.cpp */,
>+				C21BF6F821CD89BB00227979 /* WHLSLIntegerLiteral.h */,
>+				1CB69B3921DF03F3006E846A /* WHLSLIntegerLiteralType.cpp */,
>+				1CB69B3521DED649006E846A /* WHLSLIntegerLiteralType.h */,
>+				C21BF73221CD89EF00227979 /* WHLSLLogicalExpression.h */,
>+				C21BF71521CD89D400227979 /* WHLSLLogicalNotExpression.h */,
>+				C21BF72D21CD89E900227979 /* WHLSLMakeArrayReferenceExpression.h */,
>+				C21BF72C21CD89E900227979 /* WHLSLMakePointerExpression.h */,
>+				1C33277121CF0BE1000DC9F2 /* WHLSLNamedType.h */,
>+				C21BF72321CD89E100227979 /* WHLSLNativeFunctionDeclaration.h */,
>+				C21BF72A21CD89E700227979 /* WHLSLNativeTypeDeclaration.h */,
>+				C21BF72421CD89E100227979 /* WHLSLNode.h */,
>+				C21BF70721CD89C800227979 /* WHLSLNullLiteral.h */,
>+				1CB69B3A21DF0403006E846A /* WHLSLNullLiteralType.cpp */,
>+				1CB69B3621DED657006E846A /* WHLSLNullLiteralType.h */,
>+				C21BF72121CD89DE00227979 /* WHLSLNumThreadsFunctionAttribute.h */,
>+				C21BF72F21CD89EC00227979 /* WHLSLPointerType.h */,
>+				C21BF72E21CD89EA00227979 /* WHLSLPropertyAccessExpression.h */,
>+				C21BF70B21CD89CC00227979 /* WHLSLQualifier.h */,
>+				C21BF71B21CD89D900227979 /* WHLSLReadModifyWriteExpression.h */,
>+				C21BF70D21CD89CD00227979 /* WHLSLReferenceType.h */,
>+				1CB69B3221DED40B006E846A /* WHLSLResolvableType.h */,
>+				C2138A1521DDECE900F516BA /* WHLSLResourceSemantic.cpp */,
>+				C21BF70821CD89C900227979 /* WHLSLResourceSemantic.h */,
>+				C21BF70321CD89C500227979 /* WHLSLReturn.h */,
>+				C21BF6F921CD89BD00227979 /* WHLSLSemantic.h */,
>+				C2138A1621DDECFB00F516BA /* WHLSLSpecializationConstantSemantic.cpp */,
>+				C21BF73621CD89F300227979 /* WHLSLSpecializationConstantSemantic.h */,
>+				C2138A1721DDED0D00F516BA /* WHLSLStageInOutSemantic.cpp */,
>+				C21BF70E21CD89CE00227979 /* WHLSLStageInOutSemantic.h */,
>+				C21BF71221CD89D100227979 /* WHLSLStatement.h */,
>+				C21BF72721CD89E400227979 /* WHLSLStructureDefinition.h */,
>+				C21BF6FE21CD89C100227979 /* WHLSLStructureElement.h */,
>+				C21BF71921CD89D700227979 /* WHLSLSwitchCase.h */,
>+				C21BF73121CD89EE00227979 /* WHLSLSwitchStatement.h */,
>+				C21BF71C21CD89DA00227979 /* WHLSLTernaryExpression.h */,
>+				C21BF6F321CD89AD00227979 /* WHLSLTrap.h */,
>+				C21BF71D21CD89DB00227979 /* WHLSLType.h */,
>+				C288C72D21C991DA002DF5CA /* WHLSLTypeArgument.cpp */,
>+				C21BF71121CD89D100227979 /* WHLSLTypeArgument.h */,
>+				C21BF72921CD89E600227979 /* WHLSLTypeDefinition.h */,
>+				C20F4F6421DFBE5C0070C45A /* WHLSLTypeReference.cpp */,
>+				C21BF71F21CD89DC00227979 /* WHLSLTypeReference.h */,
>+				1C33277221CF0D2E000DC9F2 /* WHLSLUnnamedType.h */,
>+				C20F4F6721DFF3A70070C45A /* WHLSLUnsignedIntegerLiteral.cpp */,
>+				C21BF72B21CD89E800227979 /* WHLSLUnsignedIntegerLiteral.h */,
>+				1CB69B3B21DF041E006E846A /* WHLSLUnsignedIntegerLiteralType.cpp */,
>+				1CB69B3721DED66B006E846A /* WHLSLUnsignedIntegerLiteralType.h */,
>+				C21BF6FC21CD89BF00227979 /* WHLSLValue.h */,
>+				C21BF71021CD89D000227979 /* WHLSLVariableDeclaration.h */,
>+				C21BF71421CD89D300227979 /* WHLSLVariableDeclarationsStatement.h */,
>+				C21BF71321CD89D200227979 /* WHLSLVariableReference.h */,
>+				C21BF70421CD89C600227979 /* WHLSLWhileLoop.h */,
>+			);
>+			path = AST;
>+			sourceTree = "<group>";
>+		};
> 		1CDD44660BA9C80000F90147 /* Configurations */ = {
> 			isa = PBXGroup;
> 			children = (
>@@ -25459,6 +25554,7 @@
> 			isa = PBXGroup;
> 			children = (
> 				1CA0C2F621EEDAD200A11860 /* AST */,
>+				C26D2C6E21F05CDE00497899 /* Metal */,
> 				C234A9B221E92C1F003C984D /* WHLSLCheckDuplicateFunctions.cpp */,
> 				C234A9AE21E92C1A003C984D /* WHLSLCheckDuplicateFunctions.h */,
> 				1C840B9B21EC400900D0500D /* WHLSLChecker.cpp */,
>@@ -25508,98 +25604,13 @@
> 			path = WHLSL;
> 			sourceTree = "<group>";
> 		};
>-		1CA0C2F621EEDAD200A11860 /* AST */ = {
>+		C26D2C6E21F05CDE00497899 /* Metal */ = {
> 			isa = PBXGroup;
> 			children = (
>-				1C840B9021EC30F900D0500D /* WHLSLAddressSpace.h */,
>-				C21BF72521CD89E200227979 /* WHLSLArrayReferenceType.h */,
>-				C21BF70921CD89CA00227979 /* WHLSLArrayType.h */,
>-				C21BF73021CD89ED00227979 /* WHLSLAssignmentExpression.h */,
>-				C21BF70A21CD89CB00227979 /* WHLSLBaseFunctionAttribute.h */,
>-				C21BF6FA21CD89BE00227979 /* WHLSLBaseSemantic.h */,
>-				C21BF71E21CD89DC00227979 /* WHLSLBlock.h */,
>-				C21BF6F621CD89B700227979 /* WHLSLBooleanLiteral.h */,
>-				C21BF71A21CD89D800227979 /* WHLSLBreak.h */,
>-				C2138A1321DDECD300F516BA /* WHLSLBuiltInSemantic.cpp */,
>-				C21BF72221CD89DF00227979 /* WHLSLBuiltInSemantic.h */,
>-				C21BF71621CD89D500227979 /* WHLSLCallExpression.h */,
>-				C21BF70621CD89C700227979 /* WHLSLCommaExpression.h */,
>-				C21BF73321CD89F000227979 /* WHLSLConstantExpression.h */,
>-				C21BF6F521CD89B500227979 /* WHLSLContinue.h */,
>-				C21BF70121CD89C400227979 /* WHLSLDereferenceExpression.h */,
>-				C21BF71821CD89D700227979 /* WHLSLDotExpression.h */,
>-				C21BF6FB21CD89BE00227979 /* WHLSLDoWhileLoop.h */,
>-				C21BF72821CD89E500227979 /* WHLSLEffectfulExpressionStatement.h */,
>-				1C840B7D21EBE0B800D0500D /* WHLSLEntryPointType.h */,
>-				C21BF72021CD89DD00227979 /* WHLSLEnumerationDefinition.h */,
>-				C21BF72621CD89E300227979 /* WHLSLEnumerationMember.h */,
>-				C21BF70221CD89C400227979 /* WHLSLEnumerationMemberLiteral.h */,
>-				C21BF70C21CD89CC00227979 /* WHLSLExpression.h */,
>-				C21BF70021CD89C200227979 /* WHLSLFallthrough.h */,
>-				C21BF73521CD89F200227979 /* WHLSLFloatLiteral.h */,
>-				1CB69B3821DF03E1006E846A /* WHLSLFloatLiteralType.cpp */,
>-				1CB69B3421DED63A006E846A /* WHLSLFloatLiteralType.h */,
>-				C21BF73421CD89F100227979 /* WHLSLForLoop.h */,
>-				C21BF70521CD89C700227979 /* WHLSLFunctionAttribute.h */,
>-				C21BF6FD21CD89C000227979 /* WHLSLFunctionDeclaration.h */,
>-				C21BF6F421CD89B300227979 /* WHLSLFunctionDefinition.h */,
>-				C21BF6FF21CD89C200227979 /* WHLSLIfStatement.h */,
>-				C21BF6F721CD89B900227979 /* WHLSLIndexExpression.h */,
>-				C20F4F6621DFF2360070C45A /* WHLSLIntegerLiteral.cpp */,
>-				C21BF6F821CD89BB00227979 /* WHLSLIntegerLiteral.h */,
>-				1CB69B3921DF03F3006E846A /* WHLSLIntegerLiteralType.cpp */,
>-				1CB69B3521DED649006E846A /* WHLSLIntegerLiteralType.h */,
>-				C21BF73221CD89EF00227979 /* WHLSLLogicalExpression.h */,
>-				C21BF71521CD89D400227979 /* WHLSLLogicalNotExpression.h */,
>-				C21BF72D21CD89E900227979 /* WHLSLMakeArrayReferenceExpression.h */,
>-				C21BF72C21CD89E900227979 /* WHLSLMakePointerExpression.h */,
>-				1C33277121CF0BE1000DC9F2 /* WHLSLNamedType.h */,
>-				C21BF72321CD89E100227979 /* WHLSLNativeFunctionDeclaration.h */,
>-				C21BF72A21CD89E700227979 /* WHLSLNativeTypeDeclaration.h */,
>-				C21BF72421CD89E100227979 /* WHLSLNode.h */,
>-				C21BF70721CD89C800227979 /* WHLSLNullLiteral.h */,
>-				1CB69B3A21DF0403006E846A /* WHLSLNullLiteralType.cpp */,
>-				1CB69B3621DED657006E846A /* WHLSLNullLiteralType.h */,
>-				C21BF72121CD89DE00227979 /* WHLSLNumThreadsFunctionAttribute.h */,
>-				C21BF72F21CD89EC00227979 /* WHLSLPointerType.h */,
>-				C21BF72E21CD89EA00227979 /* WHLSLPropertyAccessExpression.h */,
>-				C21BF70B21CD89CC00227979 /* WHLSLQualifier.h */,
>-				C21BF71B21CD89D900227979 /* WHLSLReadModifyWriteExpression.h */,
>-				C21BF70D21CD89CD00227979 /* WHLSLReferenceType.h */,
>-				1CB69B3221DED40B006E846A /* WHLSLResolvableType.h */,
>-				C2138A1521DDECE900F516BA /* WHLSLResourceSemantic.cpp */,
>-				C21BF70821CD89C900227979 /* WHLSLResourceSemantic.h */,
>-				C21BF70321CD89C500227979 /* WHLSLReturn.h */,
>-				C21BF6F921CD89BD00227979 /* WHLSLSemantic.h */,
>-				C2138A1621DDECFB00F516BA /* WHLSLSpecializationConstantSemantic.cpp */,
>-				C21BF73621CD89F300227979 /* WHLSLSpecializationConstantSemantic.h */,
>-				C2138A1721DDED0D00F516BA /* WHLSLStageInOutSemantic.cpp */,
>-				C21BF70E21CD89CE00227979 /* WHLSLStageInOutSemantic.h */,
>-				C21BF71221CD89D100227979 /* WHLSLStatement.h */,
>-				C21BF72721CD89E400227979 /* WHLSLStructureDefinition.h */,
>-				C21BF6FE21CD89C100227979 /* WHLSLStructureElement.h */,
>-				C21BF71921CD89D700227979 /* WHLSLSwitchCase.h */,
>-				C21BF73121CD89EE00227979 /* WHLSLSwitchStatement.h */,
>-				C21BF71C21CD89DA00227979 /* WHLSLTernaryExpression.h */,
>-				C21BF6F321CD89AD00227979 /* WHLSLTrap.h */,
>-				C21BF71D21CD89DB00227979 /* WHLSLType.h */,
>-				C288C72D21C991DA002DF5CA /* WHLSLTypeArgument.cpp */,
>-				C21BF71121CD89D100227979 /* WHLSLTypeArgument.h */,
>-				C21BF72921CD89E600227979 /* WHLSLTypeDefinition.h */,
>-				C20F4F6421DFBE5C0070C45A /* WHLSLTypeReference.cpp */,
>-				C21BF71F21CD89DC00227979 /* WHLSLTypeReference.h */,
>-				1C33277221CF0D2E000DC9F2 /* WHLSLUnnamedType.h */,
>-				C20F4F6721DFF3A70070C45A /* WHLSLUnsignedIntegerLiteral.cpp */,
>-				C21BF72B21CD89E800227979 /* WHLSLUnsignedIntegerLiteral.h */,
>-				1CB69B3B21DF041E006E846A /* WHLSLUnsignedIntegerLiteralType.cpp */,
>-				1CB69B3721DED66B006E846A /* WHLSLUnsignedIntegerLiteralType.h */,
>-				C21BF6FC21CD89BF00227979 /* WHLSLValue.h */,
>-				C21BF71021CD89D000227979 /* WHLSLVariableDeclaration.h */,
>-				C21BF71421CD89D300227979 /* WHLSLVariableDeclarationsStatement.h */,
>-				C21BF71321CD89D200227979 /* WHLSLVariableReference.h */,
>-				C21BF70421CD89C600227979 /* WHLSLWhileLoop.h */,
>+				C26D2C7021F05D5500497899 /* WHLSLTypeNamer.cpp */,
>+				C26D2C7121F05D5500497899 /* WHLSLTypeNamer.h */,
> 			);
>-			path = AST;
>+			path = Metal;
> 			sourceTree = "<group>";
> 		};
> 		C96F5EBF1B5872260091EA9D /* mediasession */ = {

Actions: View | Formatted Diff | Diff

Attachments on bug 193531: 359362 | 359401 | 359459 | 359463 | 359473 | 359643 | 359644 | 359646 | 359647