Attachment 370375 Details for Bug 198087 – WIP

[patch] WIP

b-backup.diff (text/plain), 46.56 KB, created by Saam Barati on 2019-05-21 20:04:18 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Saam Barati

Created: 2019-05-21 20:04:18 PDT

Size: 46.56 KB

patch

obsolete

>Index: Source/WebCore/ChangeLog
>===================================================================
>--- Source/WebCore/ChangeLog	(revision 245605)
>+++ Source/WebCore/ChangeLog	(working copy)
>@@ -1,3 +1,65 @@
>+2019-05-21  Saam barati  <sbarati@apple.com>
>+
>+        WHLSL: Add an AST dumper
>+        https://bugs.webkit.org/show_bug.cgi?id=198059
>+
>+        Reviewed by Myles Maxfield.
>+
>+        This patch makes it so we can dump the WHLSL program's AST.
>+        This will become useful when we're debugging passes that
>+        transform the AST.
>+        
>+        The dumper mostly prints in a style where the dump is almost
>+        valid WHLSL code. E.g, this WHLSL program:
>+        ```
>+        int foo(int arg) {
>+            return arg + 1;
>+        }
>+        ```
>+        
>+        gets dumped as:
>+        ```
>+        int foo(int arg) {
>+           return operator+(arg, 1);
>+        }
>+        ```
>+        
>+        This patch also adds a way to dump between each pass, after
>+        parsing, or at the end of all passes. Currently, this is controlled
>+        by a static variable. I'll make these runtime configurable in a follow
>+        up: https://bugs.webkit.org/show_bug.cgi?id=198097
>+
>+        No new tests because this is used for logging.
>+
>+        * Modules/webgpu/WHLSL/AST/WHLSLAST.h: Added.
>+        * Modules/webgpu/WHLSL/AST/WHLSLAddressSpace.h:
>+        (WebCore::WHLSL::AST::toString):
>+        * Modules/webgpu/WHLSL/AST/WHLSLBuiltInSemantic.h:
>+        (WebCore::WHLSL::AST::BuiltInSemantic::toString const):
>+        * Modules/webgpu/WHLSL/AST/WHLSLEntryPointType.h:
>+        (WebCore::WHLSL::AST::toString):
>+        * Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.h:
>+        (WebCore::WHLSL::AST::ResourceSemantic::toString):
>+        * Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp:
>+        (WebCore::WHLSL::Metal::toString): Deleted.
>+        * Modules/webgpu/WHLSL/WHLSLASTDumper.cpp: Added.
>+        (WebCore::WHLSL::ASTDumper::visit):
>+        * Modules/webgpu/WHLSL/WHLSLASTDumper.h: Added.
>+        (WebCore::WHLSL::ASTDumper::toString):
>+        (WebCore::WHLSL::ASTDumper::Indent::Indent):
>+        (WebCore::WHLSL::ASTDumper::bumpIndent):
>+        (WebCore::WHLSL::toString):
>+        (WebCore::WHLSL::dumpAST):
>+        * Modules/webgpu/WHLSL/WHLSLPrepare.cpp:
>+        (WebCore::WHLSL::dumpASTIfNeeded):
>+        (WebCore::WHLSL::dumpASTAfterParsingIfNeeded):
>+        (WebCore::WHLSL::dumpASTBetweenEachPassIfNeeded):
>+        (WebCore::WHLSL::dumpASTAtEndIfNeeded):
>+        (WebCore::WHLSL::prepareShared):
>+        * Modules/webgpu/WHLSL/WHLSLVisitor.cpp:
>+        * Sources.txt:
>+        * WebCore.xcodeproj/project.pbxproj:
>+
> 2019-05-21  Myles C. Maxfield  <mmaxfield@apple.com>
> 
>         font-optical-sizing applies the wrong variation value
>Index: Source/WebCore/Sources.txt
>===================================================================
>--- Source/WebCore/Sources.txt	(revision 245539)
>+++ Source/WebCore/Sources.txt	(working copy)
>@@ -306,6 +306,7 @@ Modules/websockets/WorkerThreadableWebSo
> 
> Modules/webgpu/GPUCanvasContext.cpp
> Modules/webgpu/NavigatorGPU.cpp
>+Modules/webgpu/WHLSL/WHLSLASTDumper.cpp
> Modules/webgpu/WHLSL/WHLSLInferTypes.cpp
> Modules/webgpu/WHLSL/WHLSLLexer.cpp
> Modules/webgpu/WHLSL/WHLSLParser.cpp
>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.cpp
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.cpp	(nonexistent)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.cpp	(working copy)
>@@ -0,0 +1,648 @@
>+/*
>+ * 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 "WHLSLASTDumper.h"
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLAST.h"
>+#include "WHLSLProgram.h"
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+void ASTDumper::visit(Program& program)
>+{
>+    m_out.println();
>+
>+    for (size_t i = 0; i < program.nativeTypeDeclarations().size(); ++i)
>+        visit(program.nativeTypeDeclarations()[i]);
>+    if (program.nativeTypeDeclarations().size())
>+        m_out.print("\n\n");
>+
>+    for (size_t i = 0; i < program.nativeFunctionDeclarations().size(); ++i)
>+        visit(program.nativeFunctionDeclarations()[i]);
>+    if (program.nativeFunctionDeclarations().size())
>+        m_out.print("\n\n");
>+
>+    for (size_t i = 0; i < program.typeDefinitions().size(); ++i)
>+        visit(program.typeDefinitions()[i]);
>+    if (program.typeDefinitions().size())
>+        m_out.print("\n\n");
>+
>+    for (size_t i = 0; i < program.structureDefinitions().size(); ++i)
>+        visit(program.structureDefinitions()[i]);
>+    if (program.structureDefinitions().size())
>+        m_out.print("\n\n");
>+
>+    for (size_t i = 0; i < program.enumerationDefinitions().size(); ++i)
>+        visit(program.enumerationDefinitions()[i]);
>+    if (program.enumerationDefinitions().size())
>+        m_out.print("\n\n");
>+
>+    for (size_t i = 0; i < program.functionDefinitions().size(); ++i)
>+        visit(program.functionDefinitions()[i]);
>+
>+    m_out.println();
>+}
>+
>+void ASTDumper::visit(AST::UnnamedType& unnamedType)
>+{
>+    Base::visit(unnamedType);
>+}
>+
>+void ASTDumper::visit(AST::NamedType& namedType)
>+{
>+    Base::visit(namedType);
>+}
>+
>+void ASTDumper::visit(AST::TypeDefinition& typeDefinition)
>+{
>+    m_out.print("typedef ", typeDefinition.name(), " = ");
>+    visit(typeDefinition.type());
>+    m_out.println(";");
>+}
>+
>+void ASTDumper::visit(AST::StructureDefinition& structureDefinition)
>+{
>+    m_out.println(m_indent, "struct ", structureDefinition.name(), " {");
>+    {
>+        auto indent = bumpIndent();
>+        for (auto& structureElement : structureDefinition.structureElements())
>+            visit(structureElement);
>+    }
>+    m_out.println(m_indent, "}");
>+    m_out.println();
>+}
>+
>+void ASTDumper::visit(AST::StructureElement& structureElement)
>+{
>+    m_out.print(m_indent);
>+    visit(structureElement.type());
>+    m_out.print(" ", structureElement.name());
>+    if (structureElement.semantic())
>+        visit(*structureElement.semantic());
>+    m_out.println(";");
>+}
>+
>+void ASTDumper::visit(AST::EnumerationDefinition& enumerationDefinition)
>+{
>+    m_out.print(m_indent, "enum ");
>+    visit(enumerationDefinition.type());
>+    m_out.print(" {");
>+
>+    {
>+        auto indent = bumpIndent();
>+        bool once = false;
>+        for (auto& enumerationMember : enumerationDefinition.enumerationMembers()) {
>+            if (once)
>+                m_out.print(", ");
>+            m_out.println();
>+            m_out.print(m_indent);
>+            visit(enumerationMember);
>+        }
>+    }
>+
>+    m_out.println();
>+    m_out.println(m_indent, "}");
>+    m_out.println();
>+}
>+
>+void ASTDumper::visit(AST::EnumerationMember& enumerationMember)
>+{
>+    m_out.print(enumerationMember.name());
>+    if (enumerationMember.value()) {
>+        m_out.print(" = ");
>+        visit(*enumerationMember.value());
>+    }
>+}
>+
>+void ASTDumper::visit(AST::FunctionDefinition& functionDefinition)
>+{
>+    m_out.print(m_indent);
>+    visit(static_cast<AST::FunctionDeclaration&>(functionDefinition));
>+    visit(functionDefinition.block());
>+    m_out.print("\n\n");
>+}
>+
>+void ASTDumper::visit(AST::NativeFunctionDeclaration& nativeFunctionDeclaration)
>+{
>+    m_out.print(m_indent);
>+    m_out.print("native ");
>+    visit(static_cast<AST::FunctionDeclaration&>(nativeFunctionDeclaration));
>+    m_out.println();
>+}
>+
>+void ASTDumper::visit(AST::FunctionDeclaration& functionDeclaration)
>+{
>+    visit(functionDeclaration.attributeBlock());
>+    if (functionDeclaration.entryPointType())
>+        m_out.print(AST::toString(*functionDeclaration.entryPointType()), " ");
>+    visit(functionDeclaration.type());
>+    m_out.print(" ", functionDeclaration.name(), "(");
>+    bool once = false;
>+    for (auto& parameter : functionDeclaration.parameters()) {
>+        if (once)
>+            m_out.print(", ");
>+        once = true;
>+        visit(parameter);
>+    }
>+    m_out.print(")");
>+    if (functionDeclaration.semantic())
>+        visit(*functionDeclaration.semantic());
>+    m_out.print(" ");
>+}
>+
>+void ASTDumper::visit(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    m_out.print(m_indent, "native typedef ");
>+    m_out.print(nativeTypeDeclaration.name());
>+    if (nativeTypeDeclaration.typeArguments().size()) {
>+        m_out.print("<");
>+        bool once = false;
>+        for (auto& typeArgument : nativeTypeDeclaration.typeArguments()) {
>+            if (once)
>+                m_out.print(", ");
>+            once = true;
>+            visit(typeArgument);
>+        }
>+        m_out.print(">");
>+    }
>+    m_out.println(";");
>+}
>+
>+void ASTDumper::visit(AST::TypeReference& typeReference)
>+{
>+    m_out.print(typeReference.name());
>+
>+    if (typeReference.typeArguments().size()) {
>+        bool once = false;
>+        m_out.print("<");
>+        for (auto& typeArgument : typeReference.typeArguments()) {
>+            if (once)
>+                m_out.print(", ");
>+            once = true;
>+            visit(typeArgument);
>+        }
>+        m_out.print(">");
>+    }
>+}
>+
>+void ASTDumper::visit(AST::PointerType& pointerType)
>+{
>+    visit(static_cast<AST::ReferenceType&>(pointerType));
>+    m_out.print("*");
>+}
>+
>+void ASTDumper::visit(AST::ArrayReferenceType& arrayReferenceType)
>+{
>+    visit(static_cast<AST::ReferenceType&>(arrayReferenceType));
>+    m_out.print("[]");
>+}
>+
>+void ASTDumper::visit(AST::ArrayType& arrayType)
>+{
>+    visit(arrayType.type());
>+    m_out.print("[", arrayType.numElements(), "]");
>+}
>+
>+void ASTDumper::visit(AST::TypeArgument& typeArgument)
>+{
>+    Base::visit(typeArgument);
>+}
>+
>+void ASTDumper::visit(AST::ReferenceType& referenceType)
>+{
>+    m_out.print(AST::toString(referenceType.addressSpace()), " ");
>+    visit(referenceType.elementType());
>+}
>+
>+void ASTDumper::visit(AST::Semantic& semantic)
>+{
>+    m_out.print(" : ");
>+    WTF::visit(WTF::makeVisitor([&](AST::BuiltInSemantic& builtInSemantic) {
>+        visit(builtInSemantic);
>+    }, [&](AST::ResourceSemantic& resourceSemantic) {
>+        visit(resourceSemantic);
>+    }, [&](AST::SpecializationConstantSemantic& specializationConstantSemantic) {
>+        visit(specializationConstantSemantic);
>+    }, [&](AST::StageInOutSemantic& stageInOutSemantic) {
>+        visit(stageInOutSemantic);
>+    }), semantic);
>+}
>+
>+void ASTDumper::visit(AST::ConstantExpression& constantExpression)
>+{
>+    Base::visit(constantExpression);
>+}
>+
>+void ASTDumper::visit(AST::AttributeBlock& attributeBlock)
>+{
>+    if (attributeBlock.isEmpty())
>+        return;
>+
>+    m_out.print("[");
>+    for (auto& functionAttribute : attributeBlock)
>+        visit(functionAttribute);
>+    m_out.print("] ");
>+}
>+
>+void ASTDumper::visit(AST::BuiltInSemantic& builtInSemantic)
>+{
>+    m_out.print(builtInSemantic.toString());
>+}
>+
>+void ASTDumper::visit(AST::ResourceSemantic& resourceSemantic)
>+{
>+    m_out.print(resourceSemantic.toString());
>+}
>+
>+void ASTDumper::visit(AST::SpecializationConstantSemantic&)
>+{
>+    // FIXME: Handle this when we implement it.
>+}
>+
>+void ASTDumper::visit(AST::StageInOutSemantic& stageInOutSemantic)
>+{
>+    m_out.print("attribute(", stageInOutSemantic.index(), ")");
>+}
>+
>+void ASTDumper::visit(AST::IntegerLiteral& integerLiteral)
>+{
>+    m_out.print(integerLiteral.value());
>+}
>+
>+void ASTDumper::visit(AST::UnsignedIntegerLiteral& unsignedIntegerLiteral)
>+{
>+    m_out.print(unsignedIntegerLiteral.value());
>+}
>+
>+void ASTDumper::visit(AST::FloatLiteral& floatLiteral)
>+{
>+    m_out.print(floatLiteral.value());
>+}
>+
>+void ASTDumper::visit(AST::NullLiteral& nullLiteral)
>+{
>+    m_out.print("null");
>+    visit(nullLiteral.type());
>+}
>+
>+void ASTDumper::visit(AST::BooleanLiteral& booleanLiteral)
>+{
>+    if (booleanLiteral.value())
>+        m_out.print("true");
>+    else
>+        m_out.print("false");
>+}
>+
>+void ASTDumper::visit(AST::IntegerLiteralType&)
>+{
>+}
>+
>+void ASTDumper::visit(AST::UnsignedIntegerLiteralType&)
>+{
>+}
>+
>+void ASTDumper::visit(AST::FloatLiteralType&)
>+{
>+}
>+
>+void ASTDumper::visit(AST::NullLiteralType&)
>+{
>+}
>+
>+void ASTDumper::visit(AST::EnumerationMemberLiteral& enumerationMemberLiteral)
>+{
>+    m_out.print(enumerationMemberLiteral.left(), ".", enumerationMemberLiteral.right());
>+}
>+
>+void ASTDumper::visit(AST::FunctionAttribute& functionAttribute)
>+{
>+    WTF::visit(WTF::makeVisitor([&](AST::NumThreadsFunctionAttribute& numThreadsFunctionAttribute) {
>+        visit(numThreadsFunctionAttribute);
>+    }), functionAttribute);
>+}
>+
>+void ASTDumper::visit(AST::NumThreadsFunctionAttribute& numThreadsAttribute)
>+{
>+    m_out.print("numthreads(", numThreadsAttribute.width(), ", ", numThreadsAttribute.height(), ", ", numThreadsAttribute.depth(), ")");
>+}
>+
>+void ASTDumper::visit(AST::Block& block)
>+{
>+    m_out.println("{");
>+    {
>+        auto indent = bumpIndent();
>+        for (auto& statement : block.statements()) {
>+            m_out.print(m_indent);
>+            visit(statement);
>+            m_out.println(";");
>+        }
>+    }
>+    m_out.print(m_indent, "}");
>+}
>+
>+void ASTDumper::visit(AST::Statement& statement)
>+{
>+    Base::visit(statement);
>+}
>+
>+void ASTDumper::visit(AST::Break&)
>+{
>+    m_out.print("break");
>+}
>+
>+void ASTDumper::visit(AST::Continue&)
>+{
>+    m_out.print("continue");
>+}
>+
>+void ASTDumper::visit(AST::WhileLoop& whileLoop)
>+{
>+    m_out.print("while (");
>+    visit(whileLoop.conditional());
>+    m_out.print(")");
>+    visit(whileLoop.body());
>+}
>+
>+void ASTDumper::visit(AST::DoWhileLoop& doWhileLoop)
>+{
>+    m_out.print("do ");
>+    visit(doWhileLoop.body());
>+    m_out.print(" while(");
>+    visit(doWhileLoop.conditional());
>+    m_out.print(")");
>+}
>+
>+void ASTDumper::visit(AST::ForLoop& forLoop)
>+{
>+    m_out.print("for (");
>+    WTF::visit(WTF::makeVisitor([&](AST::VariableDeclarationsStatement& variableDeclarationsStatement) {
>+        visit(variableDeclarationsStatement);
>+    }, [&](UniqueRef<AST::Expression>& expression) {
>+        visit(expression);
>+    }), forLoop.initialization());
>+    m_out.print("; ");
>+    if (forLoop.condition())
>+        visit(*forLoop.condition());
>+    m_out.print("; ");
>+    if (forLoop.increment())
>+        visit(*forLoop.increment());
>+    m_out.print(") ");
>+    visit(forLoop.body());
>+}
>+
>+void ASTDumper::visit(AST::Expression& expression)
>+{
>+    Base::visit(expression);
>+}
>+
>+void ASTDumper::visit(AST::DotExpression& dotExpression)
>+{
>+    visit(static_cast<AST::PropertyAccessExpression&>(dotExpression));
>+    m_out.print(".", dotExpression.fieldName());
>+}
>+
>+void ASTDumper::visit(AST::IndexExpression& indexExpression)
>+{
>+    visit(static_cast<AST::PropertyAccessExpression&>(indexExpression));
>+    m_out.print("[");
>+    visit(indexExpression.indexExpression());
>+    m_out.print("]");
>+}
>+
>+void ASTDumper::visit(AST::PropertyAccessExpression& expression)
>+{
>+    Base::visit(expression);
>+}
>+
>+void ASTDumper::visit(AST::EffectfulExpressionStatement& effectfulExpressionStatement)
>+{
>+    Base::visit(effectfulExpressionStatement);
>+}
>+
>+void ASTDumper::visit(AST::Fallthrough&)
>+{
>+    m_out.print("fallthrough");
>+}
>+
>+void ASTDumper::visit(AST::IfStatement& ifStatement)
>+{
>+    m_out.print("if (");
>+    visit(ifStatement.conditional());
>+    m_out.print(") ");
>+    visit(ifStatement.body());
>+    if (ifStatement.elseBody()) {
>+        m_out.print(" else ");
>+        visit(*ifStatement.elseBody());
>+    }
>+}
>+
>+void ASTDumper::visit(AST::Return& returnStatement)
>+{
>+    m_out.print("return");
>+    if (returnStatement.value()) {
>+        m_out.print(" ");
>+        visit(*returnStatement.value());
>+    }
>+}
>+
>+void ASTDumper::visit(AST::Trap&)
>+{
>+    m_out.print("trap");
>+}
>+
>+void ASTDumper::visit(AST::SwitchStatement& switchStatement)
>+{
>+    m_out.print("switch (");
>+    visit(switchStatement.value());
>+    m_out.println(") {");
>+    bool once = false;
>+    for (auto& switchCase : switchStatement.switchCases()) {
>+        if (once)
>+            m_out.println();
>+        once = true;
>+        m_out.print(m_indent);
>+        visit(switchCase);
>+    }
>+    m_out.print("\n", m_indent, "}");
>+
>+}
>+
>+void ASTDumper::visit(AST::SwitchCase& switchCase)
>+{
>+    if (switchCase.value()) {
>+        m_out.print("case ");
>+        visit(*switchCase.value());
>+        m_out.print(": ");
>+    } else
>+        m_out.print("default: ");
>+    visit(switchCase.block());
>+}
>+
>+void ASTDumper::visit(AST::VariableDeclarationsStatement& variableDeclarationsStatement)
>+{
>+    Base::visit(variableDeclarationsStatement);
>+}
>+
>+void ASTDumper::visit(AST::VariableDeclaration& variableDeclaration)
>+{
>+    if (variableDeclaration.type()) {
>+        visit(*variableDeclaration.type());
>+        m_out.print(" ");
>+    }
>+    m_out.print(variableDeclaration.name());
>+    if (variableDeclaration.semantic())
>+        visit(*variableDeclaration.semantic());
>+    if (variableDeclaration.initializer()) {
>+        m_out.print(" = ");
>+        visit(*variableDeclaration.initializer());
>+    }
>+}
>+
>+void ASTDumper::visit(AST::AssignmentExpression& assignmentExpression)
>+{
>+    visit(assignmentExpression.left());
>+    m_out.print(" = ");
>+    visit(assignmentExpression.right());
>+}
>+
>+void ASTDumper::visit(AST::CallExpression& callExpression)
>+{
>+    m_out.print(callExpression.name(), "(");
>+    bool once = false;
>+    for (auto& argument : callExpression.arguments()) {
>+        if (once)
>+            m_out.print(", ");
>+        once = true;
>+        visit(argument);
>+    }
>+    m_out.print(")");
>+}
>+
>+void ASTDumper::visit(AST::CommaExpression& commaExpression)
>+{
>+    m_out.print("(");
>+    bool once = false;
>+    for (auto& expression : commaExpression.list()) {
>+        if (once)
>+            m_out.print(", ");
>+        once = true;
>+        visit(expression);
>+    }
>+    m_out.print(")");
>+}
>+
>+void ASTDumper::visit(AST::DereferenceExpression& dereferenceExpression)
>+{
>+    m_out.print("*");
>+    visit(dereferenceExpression.pointer());
>+}
>+
>+void ASTDumper::visit(AST::LogicalExpression& logicalExpression)
>+{
>+    m_out.print("(");
>+    visit(logicalExpression.left());
>+    switch (logicalExpression.type()) {
>+    case AST::LogicalExpression::Type::And:
>+        m_out.print(" && ");
>+        break;
>+    case AST::LogicalExpression::Type::Or:
>+        m_out.print(" || ");
>+        break;
>+    }
>+    visit(logicalExpression.right());
>+    m_out.print(")");
>+}
>+
>+void ASTDumper::visit(AST::LogicalNotExpression& logicalNotExpression)
>+{
>+    m_out.print("!(");
>+    visit(logicalNotExpression.operand());
>+    m_out.print(")");
>+}
>+
>+void ASTDumper::visit(AST::MakeArrayReferenceExpression& makeArrayReferenceExpression)
>+{
>+    m_out.print("@");
>+    visit(makeArrayReferenceExpression.lValue());
>+}
>+
>+void ASTDumper::visit(AST::MakePointerExpression& makePointerExpression)
>+{
>+    m_out.print("&");
>+    visit(makePointerExpression.lValue());
>+}
>+
>+void ASTDumper::visit(AST::ReadModifyWriteExpression& readModifyWriteExpression)
>+{
>+    auto oldVariable = readModifyWriteExpression.oldVariableReference();
>+    auto newVariable = readModifyWriteExpression.newVariableReference();
>+
>+    m_out.print("(");
>+    visit(oldVariable.get());
>+    m_out.print(" = ");
>+    visit(readModifyWriteExpression.lValue());
>+    m_out.print(", ");
>+
>+    visit(newVariable.get());
>+    m_out.print(" = ");
>+    visit(*readModifyWriteExpression.newValueExpression());
>+    m_out.print(", ");
>+
>+    visit(readModifyWriteExpression.lValue());
>+    m_out.print(" = ");
>+    visit(newVariable.get());
>+    m_out.print(", ");
>+
>+    visit(*readModifyWriteExpression.resultExpression());
>+    m_out.print(")");
>+}
>+
>+void ASTDumper::visit(AST::TernaryExpression& ternaryExpression)
>+{
>+    visit(ternaryExpression.predicate());
>+    m_out.print(" ? ");
>+    visit(ternaryExpression.bodyExpression());
>+    m_out.print(" : ");
>+    visit(ternaryExpression.elseExpression());
>+}
>+
>+void ASTDumper::visit(AST::VariableReference& variableReference)
>+{
>+    if (variableReference.name().isEmpty())
>+        m_out.print("$(", RawPointer(variableReference.variable()), ")");
>+    else
>+        m_out.print(variableReference.name());
>+}
>+
>+} // namespace WHLSL
>+
>+} // namespace WebCore
>+
>+#endif
>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.h
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.h	(nonexistent)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.h	(working copy)
>@@ -0,0 +1,147 @@
>+/*
>+ * 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/DataLog.h>
>+#include <wtf/SetForScope.h>
>+#include <wtf/StringPrintStream.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+class ASTDumper : Visitor {
>+    using Base = Visitor;
>+public:
>+    void visit(Program&) override;
>+
>+    String toString() { return m_out.toString(); }
>+
>+private:
>+    void visit(AST::UnnamedType&) override;
>+    void visit(AST::NamedType&) override;
>+    void visit(AST::TypeDefinition&) override;
>+    void visit(AST::StructureDefinition&) override;
>+    void visit(AST::EnumerationDefinition&) override;
>+    void visit(AST::FunctionDefinition&) override;
>+    void visit(AST::NativeFunctionDeclaration&) override;
>+    void visit(AST::NativeTypeDeclaration&) override;
>+    void visit(AST::TypeReference&) override;
>+    void visit(AST::PointerType&) override;
>+    void visit(AST::ArrayReferenceType&) override;
>+    void visit(AST::ArrayType&) override;
>+    void visit(AST::StructureElement&) override;
>+    void visit(AST::EnumerationMember&) override;
>+    void visit(AST::FunctionDeclaration&) override;
>+    void visit(AST::TypeArgument&) override;
>+    void visit(AST::ReferenceType&) override;
>+    void visit(AST::Semantic&) override;
>+    void visit(AST::ConstantExpression&) override;
>+    void visit(AST::AttributeBlock&) override;
>+    void visit(AST::BuiltInSemantic&) override;
>+    void visit(AST::ResourceSemantic&) override;
>+    void visit(AST::SpecializationConstantSemantic&) override;
>+    void visit(AST::StageInOutSemantic&) override;
>+    void visit(AST::IntegerLiteral&) override;
>+    void visit(AST::UnsignedIntegerLiteral&) override;
>+    void visit(AST::FloatLiteral&) override;
>+    void visit(AST::NullLiteral&) override;
>+    void visit(AST::BooleanLiteral&) override;
>+    void visit(AST::IntegerLiteralType&) override;
>+    void visit(AST::UnsignedIntegerLiteralType&) override;
>+    void visit(AST::FloatLiteralType&) override;
>+    void visit(AST::NullLiteralType&) override;
>+    void visit(AST::EnumerationMemberLiteral&) override;
>+    void visit(AST::FunctionAttribute&) override;
>+    void visit(AST::NumThreadsFunctionAttribute&) override;
>+    void visit(AST::Block&) override;
>+    void visit(AST::Statement&) override;
>+    void visit(AST::Break&) override;
>+    void visit(AST::Continue&) override;
>+    void visit(AST::DoWhileLoop&) override;
>+    void visit(AST::Expression&) override;
>+    void visit(AST::DotExpression&) override;
>+    void visit(AST::IndexExpression&) override;
>+    void visit(AST::PropertyAccessExpression&) override;
>+    void visit(AST::EffectfulExpressionStatement&) override;
>+    void visit(AST::Fallthrough&) override;
>+    void visit(AST::ForLoop&) override;
>+    void visit(AST::IfStatement&) override;
>+    void visit(AST::Return&) override;
>+    void visit(AST::SwitchCase&) override;
>+    void visit(AST::SwitchStatement&) override;
>+    void visit(AST::Trap&) override;
>+    void visit(AST::VariableDeclarationsStatement&) override;
>+    void visit(AST::WhileLoop&) override;
>+    void visit(AST::VariableDeclaration&) override;
>+    void visit(AST::AssignmentExpression&) override;
>+    void visit(AST::CallExpression&) override;
>+    void visit(AST::CommaExpression&) override;
>+    void visit(AST::DereferenceExpression&) override;
>+    void visit(AST::LogicalExpression&) override;
>+    void visit(AST::LogicalNotExpression&) override;
>+    void visit(AST::MakeArrayReferenceExpression&) override;
>+    void visit(AST::MakePointerExpression&) override;
>+    void visit(AST::ReadModifyWriteExpression&) override;
>+    void visit(AST::TernaryExpression&) override;
>+    void visit(AST::VariableReference&) override;
>+
>+    struct Indent {
>+        Indent(ASTDumper& dumper)
>+            : m_scope(dumper.m_indent, dumper.m_indent + "   ")
>+        { }
>+        SetForScope<String> m_scope;
>+    };
>+
>+    Indent bumpIndent() { return Indent(*this); }
>+
>+    friend struct Indent;
>+
>+    StringPrintStream m_out;
>+    String m_indent;
>+};
>+
>+static ALWAYS_INLINE String toString(Program& program)
>+{
>+    ASTDumper dumper;
>+    dumper.visit(program);
>+    return dumper.toString();
>+}
>+
>+static ALWAYS_INLINE void dumpAST(Program& program)
>+{
>+    dataLogLn(toString(program));
>+}
>+
>+} // namespace WHLSL
>+
>+} // namespace WebCore
>+
>+#endif // ENABLE(WEBGPU)
>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp	(revision 245539)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp	(working copy)
>@@ -918,6 +918,7 @@ auto Parser::parseEnumerationDefinition(
>         return Unexpected<Error>(firstEnumerationMember.error());
> 
>     AST::EnumerationDefinition result(WTFMove(*origin), name->stringView.toString(), WTFMove(*type));
>+
>     auto success = result.add(WTFMove(*firstEnumerationMember));
>     if (!success)
>         return fail("Cannot add enumeration member"_str);
>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp	(revision 245539)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp	(working copy)
>@@ -28,6 +28,7 @@
> 
> #if ENABLE(WEBGPU)
> 
>+#include "WHLSLASTDumper.h"
> #include "WHLSLCheckDuplicateFunctions.h"
> #include "WHLSLChecker.h"
> #include "WHLSLFunctionStageChecker.h"
>@@ -52,6 +53,44 @@ namespace WebCore {
> 
> namespace WHLSL {
> 
>+static constexpr bool dumpASTBeforeEachPass = false;
>+static constexpr bool dumpASTAfterParsing = true;
>+static constexpr bool dumpASTAtEnd = false;
>+
>+static bool dumpASTIfNeeded(bool shouldDump, Program& program, const char* message)
>+{
>+    if (shouldDump) {
>+        dataLogLn(message);
>+        dumpAST(program);
>+        return true;
>+    }
>+
>+    return false;
>+}
>+
>+static bool dumpASTAfterParsingIfNeeded(Program& program)
>+{
>+    return dumpASTIfNeeded(dumpASTAfterParsing, program, "AST after parsing");
>+}
>+
>+static bool dumpASTBetweenEachPassIfNeeded(Program& program, const char* message)
>+{
>+    return dumpASTIfNeeded(dumpASTBeforeEachPass, program, message);
>+}
>+
>+static bool dumpASTAtEndIfNeeded(Program& program)
>+{
>+    return dumpASTIfNeeded(dumpASTAtEnd, program, "AST at end");
>+}
>+
>+#define RUN_PASS(pass, ...) \
>+    do { \
>+        dumpASTBetweenEachPassIfNeeded(program, "AST before " # pass); \
>+        if (!pass(__VA_ARGS__)) \
>+            return WTF::nullopt; \
>+    } while (0)
>+    
>+
> static Optional<Program> prepareShared(String& whlslSource)
> {
>     Program program;
>@@ -61,35 +100,31 @@ static Optional<Program> prepareShared(S
>     ASSERT_UNUSED(failure, !failure);
>     if (parser.parse(program, whlslSource, Parser::Mode::User))
>         return WTF::nullopt;
>+
>+    if (!dumpASTBetweenEachPassIfNeeded(program, "AST after parsing"))
>+        dumpASTAfterParsingIfNeeded(program);
>+
>     NameResolver nameResolver(program.nameContext());
>-    if (!resolveNamesInTypes(program, nameResolver))
>-        return WTF::nullopt;
>-    if (!checkRecursiveTypes(program))
>-        return WTF::nullopt;
>-    if (!synthesizeStructureAccessors(program))
>-        return WTF::nullopt;
>-    if (!synthesizeEnumerationFunctions(program))
>-        return WTF::nullopt;
>-    if (!synthesizeArrayOperatorLength(program))
>-        return WTF::nullopt;
>-    if (!synthesizeConstructors(program))
>-        return WTF::nullopt;
>-    if (!resolveNamesInFunctions(program, nameResolver))
>-        return WTF::nullopt;
>-    if (!checkDuplicateFunctions(program))
>-        return WTF::nullopt;
>+    RUN_PASS(resolveNamesInTypes, program, nameResolver);
>+    RUN_PASS(checkRecursiveTypes, program);
>+    RUN_PASS(synthesizeStructureAccessors, program);
>+    RUN_PASS(synthesizeEnumerationFunctions, program);
>+    RUN_PASS(synthesizeArrayOperatorLength, program);
>+    RUN_PASS(synthesizeConstructors, program);
>+    RUN_PASS(resolveNamesInFunctions, program, nameResolver);
>+    RUN_PASS(checkDuplicateFunctions, program);
>+
>+    RUN_PASS(check, program);
> 
>-    if (!check(program))
>-        return WTF::nullopt;
>     checkLiteralTypes(program);
>     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195788 Resolve properties here
>     findHighZombies(program);
>-    if (!checkStatementBehavior(program))
>-        return WTF::nullopt;
>-    if (!checkRecursion(program))
>-        return WTF::nullopt;
>-    if (!checkFunctionStages(program))
>-        return WTF::nullopt;
>+    RUN_PASS(checkStatementBehavior, program);
>+    RUN_PASS(checkRecursion, program);
>+    RUN_PASS(checkFunctionStages, program);
>+
>+    dumpASTAtEndIfNeeded(program);
>+
>     return program;
> }
> 
>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp	(revision 245539)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp	(working copy)
>@@ -28,73 +28,7 @@
> 
> #if ENABLE(WEBGPU)
> 
>-#include "WHLSLArrayReferenceType.h"
>-#include "WHLSLArrayType.h"
>-#include "WHLSLAssignmentExpression.h"
>-#include "WHLSLBaseFunctionAttribute.h"
>-#include "WHLSLBaseSemantic.h"
>-#include "WHLSLBlock.h"
>-#include "WHLSLBooleanLiteral.h"
>-#include "WHLSLBreak.h"
>-#include "WHLSLBuiltInSemantic.h"
>-#include "WHLSLCallExpression.h"
>-#include "WHLSLCommaExpression.h"
>-#include "WHLSLConstantExpression.h"
>-#include "WHLSLContinue.h"
>-#include "WHLSLDereferenceExpression.h"
>-#include "WHLSLDoWhileLoop.h"
>-#include "WHLSLDotExpression.h"
>-#include "WHLSLEffectfulExpressionStatement.h"
>-#include "WHLSLEnumerationDefinition.h"
>-#include "WHLSLEnumerationMember.h"
>-#include "WHLSLEnumerationMemberLiteral.h"
>-#include "WHLSLExpression.h"
>-#include "WHLSLFallthrough.h"
>-#include "WHLSLFloatLiteral.h"
>-#include "WHLSLForLoop.h"
>-#include "WHLSLFunctionAttribute.h"
>-#include "WHLSLFunctionDeclaration.h"
>-#include "WHLSLFunctionDefinition.h"
>-#include "WHLSLIfStatement.h"
>-#include "WHLSLIndexExpression.h"
>-#include "WHLSLIntegerLiteral.h"
>-#include "WHLSLLogicalExpression.h"
>-#include "WHLSLLogicalNotExpression.h"
>-#include "WHLSLMakeArrayReferenceExpression.h"
>-#include "WHLSLMakePointerExpression.h"
>-#include "WHLSLNativeFunctionDeclaration.h"
>-#include "WHLSLNativeTypeDeclaration.h"
>-#include "WHLSLNode.h"
>-#include "WHLSLNullLiteral.h"
>-#include "WHLSLNumThreadsFunctionAttribute.h"
>-#include "WHLSLPointerType.h"
>-#include "WHLSLProgram.h"
>-#include "WHLSLPropertyAccessExpression.h"
>-#include "WHLSLQualifier.h"
>-#include "WHLSLReadModifyWriteExpression.h"
>-#include "WHLSLReferenceType.h"
>-#include "WHLSLResourceSemantic.h"
>-#include "WHLSLReturn.h"
>-#include "WHLSLSemantic.h"
>-#include "WHLSLSpecializationConstantSemantic.h"
>-#include "WHLSLStageInOutSemantic.h"
>-#include "WHLSLStatement.h"
>-#include "WHLSLStructureDefinition.h"
>-#include "WHLSLStructureElement.h"
>-#include "WHLSLSwitchCase.h"
>-#include "WHLSLSwitchStatement.h"
>-#include "WHLSLTernaryExpression.h"
>-#include "WHLSLTrap.h"
>-#include "WHLSLType.h"
>-#include "WHLSLTypeArgument.h"
>-#include "WHLSLTypeDefinition.h"
>-#include "WHLSLTypeReference.h"
>-#include "WHLSLUnsignedIntegerLiteral.h"
>-#include "WHLSLValue.h"
>-#include "WHLSLVariableDeclaration.h"
>-#include "WHLSLVariableDeclarationsStatement.h"
>-#include "WHLSLVariableReference.h"
>-#include "WHLSLWhileLoop.h"
>+#include "WHLSLAST.h"
> 
> namespace WebCore {
> 
>Index: Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAST.h
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAST.h	(nonexistent)
>+++ Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAST.h	(working copy)
>@@ -0,0 +1,106 @@
>+/*
>+ * 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 "WHLSLAddressSpace.h"
>+#include "WHLSLArrayReferenceType.h"
>+#include "WHLSLArrayType.h"
>+#include "WHLSLAssignmentExpression.h"
>+#include "WHLSLBaseFunctionAttribute.h"
>+#include "WHLSLBaseSemantic.h"
>+#include "WHLSLBlock.h"
>+#include "WHLSLBooleanLiteral.h"
>+#include "WHLSLBreak.h"
>+#include "WHLSLBuiltInSemantic.h"
>+#include "WHLSLCallExpression.h"
>+#include "WHLSLCommaExpression.h"
>+#include "WHLSLConstantExpression.h"
>+#include "WHLSLContinue.h"
>+#include "WHLSLDereferenceExpression.h"
>+#include "WHLSLDoWhileLoop.h"
>+#include "WHLSLDotExpression.h"
>+#include "WHLSLEffectfulExpressionStatement.h"
>+#include "WHLSLEntryPointType.h"
>+#include "WHLSLEnumerationDefinition.h"
>+#include "WHLSLEnumerationMember.h"
>+#include "WHLSLEnumerationMemberLiteral.h"
>+#include "WHLSLExpression.h"
>+#include "WHLSLFallthrough.h"
>+#include "WHLSLFloatLiteral.h"
>+#include "WHLSLFloatLiteralType.h"
>+#include "WHLSLForLoop.h"
>+#include "WHLSLFunctionAttribute.h"
>+#include "WHLSLFunctionDeclaration.h"
>+#include "WHLSLFunctionDefinition.h"
>+#include "WHLSLIfStatement.h"
>+#include "WHLSLIndexExpression.h"
>+#include "WHLSLIntegerLiteral.h"
>+#include "WHLSLIntegerLiteralType.h"
>+#include "WHLSLLogicalExpression.h"
>+#include "WHLSLLogicalNotExpression.h"
>+#include "WHLSLMakeArrayReferenceExpression.h"
>+#include "WHLSLMakePointerExpression.h"
>+#include "WHLSLNamedType.h"
>+#include "WHLSLNativeFunctionDeclaration.h"
>+#include "WHLSLNativeTypeDeclaration.h"
>+#include "WHLSLNode.h"
>+#include "WHLSLNullLiteral.h"
>+#include "WHLSLNullLiteralType.h"
>+#include "WHLSLNumThreadsFunctionAttribute.h"
>+#include "WHLSLPointerType.h"
>+#include "WHLSLPropertyAccessExpression.h"
>+#include "WHLSLQualifier.h"
>+#include "WHLSLReadModifyWriteExpression.h"
>+#include "WHLSLReferenceType.h"
>+#include "WHLSLResolvableType.h"
>+#include "WHLSLResourceSemantic.h"
>+#include "WHLSLReturn.h"
>+#include "WHLSLSemantic.h"
>+#include "WHLSLSpecializationConstantSemantic.h"
>+#include "WHLSLStageInOutSemantic.h"
>+#include "WHLSLStatement.h"
>+#include "WHLSLStructureDefinition.h"
>+#include "WHLSLStructureElement.h"
>+#include "WHLSLSwitchCase.h"
>+#include "WHLSLSwitchStatement.h"
>+#include "WHLSLTernaryExpression.h"
>+#include "WHLSLTrap.h"
>+#include "WHLSLType.h"
>+#include "WHLSLTypeArgument.h"
>+#include "WHLSLTypeDefinition.h"
>+#include "WHLSLTypeReference.h"
>+#include "WHLSLUnnamedType.h"
>+#include "WHLSLUnsignedIntegerLiteral.h"
>+#include "WHLSLUnsignedIntegerLiteralType.h"
>+#include "WHLSLValue.h"
>+#include "WHLSLVariableDeclaration.h"
>+#include "WHLSLVariableDeclarationsStatement.h"
>+#include "WHLSLVariableReference.h"
>+#include "WHLSLWhileLoop.h"
>+
>+#endif
>Index: Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAddressSpace.h
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAddressSpace.h	(revision 245539)
>+++ Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAddressSpace.h	(working copy)
>@@ -42,6 +42,21 @@ enum class AddressSpace : uint8_t {
>     Thread
> };
> 
>+static ALWAYS_INLINE String toString(AddressSpace addressSpace)
>+{
>+    switch (addressSpace) {
>+    case AddressSpace::Constant:
>+        return "constant"_str;
>+    case AddressSpace::Device:
>+        return "device"_str;
>+    case AddressSpace::Threadgroup:
>+        return "threadgroup"_str;
>+    default:
>+        ASSERT(addressSpace == AddressSpace::Thread);
>+        return "thread"_str;
>+    }
>+}
>+
> }
> 
> }
>Index: Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLBuiltInSemantic.h
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLBuiltInSemantic.h	(revision 245539)
>+++ Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLBuiltInSemantic.h	(working copy)
>@@ -81,6 +81,40 @@ public:
>         return !(*this == other);
>     }
> 
>+    String toString() const
>+    {
>+        switch (m_variable) {
>+        case Variable::SVInstanceID:
>+            return "SVInstanceID";
>+        case Variable::SVVertexID:
>+            return "SVVertexID";
>+        case Variable::PSize:
>+            return "PSize";
>+        case Variable::SVPosition:
>+            return "SVPosition";
>+        case Variable::SVIsFrontFace:
>+            return "SVIsFrontFace";
>+        case Variable::SVSampleIndex:
>+            return "SVSampleIndex";
>+        case Variable::SVInnerCoverage:
>+            return "SVInnerCoverage";
>+        case Variable::SVTarget:
>+            return "SVTarget";
>+        case Variable::SVDepth:
>+            return "SVDepth";
>+        case Variable::SVCoverage:
>+            return "SVCoverage";
>+        case Variable::SVDispatchThreadID:
>+            return "SVDispatchThreadID";
>+        case Variable::SVGroupID:
>+            return "SVGroupID";
>+        case Variable::SVGroupIndex:
>+            return "SVGroupIndex";
>+        case Variable::SVGroupThreadID:
>+            return "SVGroupThreadID";
>+        }
>+    }
>+
>     bool isAcceptableType(const UnnamedType&, const Intrinsics&) const override;
>     bool isAcceptableForShaderItemDirection(ShaderItemDirection, const Optional<EntryPointType>&) const override;
> 
>Index: Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEntryPointType.h
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEntryPointType.h	(revision 245539)
>+++ Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEntryPointType.h	(working copy)
>@@ -42,6 +42,18 @@ enum class EntryPointType : uint8_t {
>     // FIXME: Add an entry point type for testing
> };
> 
>+static ALWAYS_INLINE String toString(EntryPointType type)
>+{
>+    switch (type) {
>+    case EntryPointType::Vertex:
>+        return "vertex";
>+    case EntryPointType::Fragment:
>+        return "fragment";
>+    case EntryPointType::Compute:
>+        return "compute";
>+    }
>+}
>+
> }
> 
> }
>Index: Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationDefinition.h
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationDefinition.h	(revision 245539)
>+++ Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEnumerationDefinition.h	(working copy)
>@@ -63,8 +63,9 @@ public:
> 
>     bool add(EnumerationMember&& member)
>     {
>-        auto result = m_members.add(member.name(), std::make_unique<EnumerationMember>(WTFMove(member)));
>-        return !result.isNewEntry;
>+        String name = member.name();
>+        auto result = m_members.add(WTFMove(name), std::make_unique<EnumerationMember>(WTFMove(member)));
>+        return result.isNewEntry;
>     }
> 
>     EnumerationMember* memberByName(const String& name)
>Index: Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.h
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.h	(revision 245539)
>+++ Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.h	(working copy)
>@@ -58,6 +58,20 @@ public:
>     ResourceSemantic(const ResourceSemantic&) = delete;
>     ResourceSemantic(ResourceSemantic&&) = default;
> 
>+    String toString()
>+    {
>+        switch (m_mode) {
>+        case Mode::UnorderedAccessView:
>+            return "UnorderedAccessView";
>+        case Mode::Texture:
>+            return "Texture";
>+        case Mode::Buffer:
>+            return "Buffer";
>+        case Mode::Sampler:
>+            return "Sampler";
>+        }
>+    }
>+
>     Mode mode() const { return m_mode; }
>     unsigned index() const { return m_index; }
>     unsigned space() const { return m_space; }
>Index: Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp	(revision 245539)
>+++ Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp	(working copy)
>@@ -380,21 +380,6 @@ String TypeNamer::metalTypeDeclarations(
>     return metalTypeDeclarationWriter.toString();
> }
> 
>-static String toString(AST::AddressSpace addressSpace)
>-{
>-    switch (addressSpace) {
>-    case AST::AddressSpace::Constant:
>-        return "constant"_str;
>-    case AST::AddressSpace::Device:
>-        return "device"_str;
>-    case AST::AddressSpace::Threadgroup:
>-        return "threadgroup"_str;
>-    default:
>-        ASSERT(addressSpace == AST::AddressSpace::Thread);
>-        return "thread"_str;
>-    }
>-}
>-
> void TypeNamer::emitUnnamedTypeDefinition(BaseTypeNameNode& baseTypeNameNode, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<BaseTypeNameNode*>& emittedUnnamedTypes, StringBuilder& stringBuilder)
> {
>     if (emittedUnnamedTypes.contains(&baseTypeNameNode))
>Index: Source/WebCore/WebCore.xcodeproj/project.pbxproj
>===================================================================
>--- Source/WebCore/WebCore.xcodeproj/project.pbxproj	(revision 245539)
>+++ Source/WebCore/WebCore.xcodeproj/project.pbxproj	(working copy)
>@@ -8314,6 +8314,7 @@
> 		51FB67D91AE6B5E400D06C5A /* ContentExtensionStyleSheet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ContentExtensionStyleSheet.cpp; sourceTree = "<group>"; };
> 		51FB67DA1AE6B5E400D06C5A /* ContentExtensionStyleSheet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ContentExtensionStyleSheet.h; sourceTree = "<group>"; };
> 		52131E5A1C4F15610033F802 /* VideoFullscreenInterfaceMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = VideoFullscreenInterfaceMac.mm; sourceTree = "<group>"; };
>+		5215862C229377B7005925EF /* WHLSLAST.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLAST.h; sourceTree = "<group>"; };
> 		526724F11CB2FDF60075974D /* TextTrackRepresentationCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = TextTrackRepresentationCocoa.mm; sourceTree = "<group>"; };
> 		526724F21CB2FDF60075974D /* TextTrackRepresentationCocoa.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TextTrackRepresentationCocoa.h; sourceTree = "<group>"; };
> 		52B0D4BD1C57FD1E0077CE53 /* PlatformView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformView.h; sourceTree = "<group>"; };
>@@ -16997,6 +16998,7 @@
> 		1CA0C2F621EEDAD200A11860 /* AST */ = {
> 			isa = PBXGroup;
> 			children = (
>+				5215862C229377B7005925EF /* WHLSLAST.h */,
> 				1C840B9021EC30F900D0500D /* WHLSLAddressSpace.h */,
> 				C21BF72521CD89E200227979 /* WHLSLArrayReferenceType.h */,
> 				C21BF70921CD89CA00227979 /* WHLSLArrayType.h */,
>Index: LayoutTests/webgpu/whlsl.html
>===================================================================
>--- LayoutTests/webgpu/whlsl.html	(revision 245539)
>+++ LayoutTests/webgpu/whlsl.html	(working copy)
>@@ -6,12 +6,14 @@
> <canvas id="canvas" width="400" height="400"></canvas>
> <script>
> const shaderSource = `
>-vertex float4 vertexShader(float4 position : attribute(0), float i : attribute(1)) : SV_Position {
>-    return position;
>+enum Foo {
>+    Bar,
>+    Baz = 42
> }
> 
>-fragment float4 fragmentShader(float4 position : SV_Position) : SV_Target 0 {
>-    return position;
>+Foo foo() {
>+    Foo foo = Foo.Bar;
>+    return Foo.Baz;
> }
> `;
> async function start() {

Actions: View | Formatted Diff | Diff

Attachments on bug 198087: 370375 | 370380 | 370466