Attachment 358882 Details for Bug 192826 – Patch

[patch] Patch

bug-192826-20190111001200.patch (text/plain), 48.06 KB, created by Myles C. Maxfield on 2019-01-11 00:12:00 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Myles C. Maxfield

Created: 2019-01-11 00:12:00 PST

Size: 48.06 KB

patch

obsolete

>Subversion Revision: 239861
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 76b62769033d12153a576529ab23321418a49b44..4a3482c160babda876ed47693c8a754b75313d97 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,25 @@
>+2019-01-11  Myles C. Maxfield  <mmaxfield@apple.com>
>+
>+        [WHLSL] Add a Visitor class
>+        https://bugs.webkit.org/show_bug.cgi?id=192826
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch exposes a bunch of the private members of WHLSL's AST nodes so that Visitor can recurse on constituent nodes.
>+        It also writes the recursion in Visitor.h. This is a virtual base class that gets subclassed for compiler passes.
>+
>+        I've split this part into its own patch to aid reviewing of the compiler.
>+
>+        * Modules/webgpu/WHLSL/AST/WHLSLStageInOutSemantic.cpp:
>+        * Modules/webgpu/WHLSL/WHLSLVisitor.cpp: Added.
>+        (WebCore::WHLSL::Visitor::visit):
>+        (WebCore::WHLSL::Visitor::checkErrorAndVisit):
>+        * Modules/webgpu/WHLSL/WHLSLVisitor.h: Added.
>+        (WebCore::WHLSL::Visitor::setError):
>+        (WebCore::WHLSL::Visitor::error const):
>+        * Sources.txt:
>+        * WebCore.xcodeproj/project.pbxproj:
>+
> 2019-01-10  Myles C. Maxfield  <mmaxfield@apple.com>
> 
>         [WHLSL] Include the standard library
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStageInOutSemantic.cpp b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStageInOutSemantic.cpp
>index 389d35ed96917c6f5c434d473ae725a976ccff6a..22572c812c839a9aa3c5ee62fb32f7104d91fec5 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStageInOutSemantic.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStageInOutSemantic.cpp
>@@ -31,6 +31,7 @@
> #include "WHLSLArrayType.h"
> #include "WHLSLEnumerationDefinition.h"
> #include "WHLSLFunctionDefinition.h"
>+#include "WHLSLNativeTypeDeclaration.h"
> #include "WHLSLTypeReference.h"
> 
> namespace WebCore {
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..8d51bff773e579906576e5c7d58c955f9d8d45ba
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp
>@@ -0,0 +1,1033 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "config.h"
>+#include "WHLSLVisitor.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 "WHLSLConstantExpressionEnumerationMemberReference.h"
>+#include "WHLSLContinue.h"
>+#include "WHLSLDereferenceExpression.h"
>+#include "WHLSLDoWhileLoop.h"
>+#include "WHLSLDotExpression.h"
>+#include "WHLSLEffectfulExpressionStatement.h"
>+#include "WHLSLEnumerationDefinition.h"
>+#include "WHLSLEnumerationMember.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"
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+void Visitor::visit(Program& program)
>+{
>+    // These visiting functions might add new global statements, so don't use foreach syntax.
>+    for (size_t i = 0; i < program.typeDefinitions().size(); ++i)
>+        checkErrorAndVisit(static_cast<AST::TypeDefinition&>(program.typeDefinitions()[i]));
>+    for (size_t i = 0; i < program.structureDefinitions().size(); ++i)
>+        checkErrorAndVisit(static_cast<AST::StructureDefinition&>(program.structureDefinitions()[i]));
>+    for (size_t i = 0; i < program.enumerationDefinitions().size(); ++i)
>+        checkErrorAndVisit(static_cast<AST::EnumerationDefinition&>(program.enumerationDefinitions()[i]));
>+    for (size_t i = 0; i < program.functionDefinitions().size(); ++i)
>+        checkErrorAndVisit(static_cast<AST::FunctionDefinition&>(program.functionDefinitions()[i]));
>+    for (size_t i = 0; i < program.nativeFunctionDeclarations().size(); ++i)
>+        checkErrorAndVisit(static_cast<AST::NativeFunctionDeclaration&>(program.nativeFunctionDeclarations()[i]));
>+    for (size_t i = 0; i < program.nativeTypeDeclarations().size(); ++i)
>+        checkErrorAndVisit(static_cast<AST::NativeTypeDeclaration&>(program.nativeTypeDeclarations()[i]));
>+}
>+
>+void Visitor::visit(AST::UnnamedType& unnamedType)
>+{
>+    if (is<AST::TypeReference>(unnamedType))
>+        checkErrorAndVisit(downcast<AST::TypeReference>(unnamedType));
>+    else if (is<AST::PointerType>(unnamedType))
>+        checkErrorAndVisit(downcast<AST::PointerType>(unnamedType));
>+    else if (is<AST::ArrayReferenceType>(unnamedType))
>+        checkErrorAndVisit(downcast<AST::ArrayReferenceType>(unnamedType));
>+    else {
>+        ASSERT(is<AST::ArrayType>(unnamedType));
>+        checkErrorAndVisit(downcast<AST::ArrayType>(unnamedType));
>+    }
>+}
>+
>+void Visitor::visit(AST::NamedType& namedType)
>+{
>+    if (is<AST::TypeDefinition>(namedType))
>+        checkErrorAndVisit(downcast<AST::TypeDefinition>(namedType));
>+    else if (is<AST::StructureDefinition>(namedType))
>+        checkErrorAndVisit(downcast<AST::StructureDefinition>(namedType));
>+    else if (is<AST::EnumerationDefinition>(namedType))
>+        checkErrorAndVisit(downcast<AST::EnumerationDefinition>(namedType));
>+    else {
>+        ASSERT(is<AST::NativeTypeDeclaration>(namedType));
>+        checkErrorAndVisit(downcast<AST::NativeTypeDeclaration>(namedType));
>+    }
>+}
>+
>+void Visitor::visit(AST::TypeDefinition& typeDefinition)
>+{
>+    checkErrorAndVisit(typeDefinition.type());
>+}
>+
>+void Visitor::visit(AST::StructureDefinition& structureDefinition)
>+{
>+    for (auto& structureElement : structureDefinition.structureElements())
>+        checkErrorAndVisit(structureElement);
>+}
>+
>+void Visitor::visit(AST::EnumerationDefinition& enumerationDefinition)
>+{
>+    if (enumerationDefinition.type())
>+        checkErrorAndVisit(static_cast<AST::UnnamedType&>(*enumerationDefinition.type()));
>+    for (auto& enumerationMember : enumerationDefinition.enumerationMembers())
>+        checkErrorAndVisit(enumerationMember);
>+}
>+
>+void Visitor::visit(AST::FunctionDefinition& functionDefinition)
>+{
>+    checkErrorAndVisit(static_cast<AST::FunctionDeclaration&>(functionDefinition));
>+    checkErrorAndVisit(functionDefinition.block());
>+}
>+
>+void Visitor::visit(AST::NativeFunctionDeclaration& nativeFunctionDeclaration)
>+{
>+    checkErrorAndVisit(static_cast<AST::FunctionDeclaration&>(nativeFunctionDeclaration));
>+}
>+
>+void Visitor::visit(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    for (auto& typeArgument : nativeTypeDeclaration.typeArguments())
>+        checkErrorAndVisit(typeArgument);
>+}
>+
>+void Visitor::visit(AST::TypeReference& typeReference)
>+{
>+    for (auto& typeArgument : typeReference.typeArguments())
>+        checkErrorAndVisit(typeArgument);
>+    if (typeReference.resolvedType() && is<AST::TypeDefinition>(*typeReference.resolvedType())) {
>+        auto& typeDefinition = downcast<AST::TypeDefinition>(*typeReference.resolvedType());
>+        checkErrorAndVisit(typeDefinition.type());
>+    }
>+}
>+
>+void Visitor::visit(AST::PointerType& pointerType)
>+{
>+    checkErrorAndVisit(static_cast<AST::ReferenceType&>(pointerType));
>+}
>+
>+void Visitor::visit(AST::ArrayReferenceType& arrayReferenceType)
>+{
>+    checkErrorAndVisit(static_cast<AST::ReferenceType&>(arrayReferenceType));
>+}
>+
>+void Visitor::visit(AST::ArrayType& arrayType)
>+{
>+    checkErrorAndVisit(arrayType.type());
>+}
>+
>+void Visitor::visit(AST::StructureElement& structureElement)
>+{
>+    checkErrorAndVisit(structureElement.type());
>+    if (structureElement.semantic())
>+        checkErrorAndVisit(*structureElement.semantic());
>+}
>+
>+void Visitor::visit(AST::EnumerationMember& enumerationMember)
>+{
>+    if (enumerationMember.value())
>+        checkErrorAndVisit(*enumerationMember.value());
>+}
>+
>+void Visitor::visit(AST::FunctionDeclaration& functionDeclaration)
>+{
>+    checkErrorAndVisit(functionDeclaration.attributeBlock());
>+    checkErrorAndVisit(functionDeclaration.type());
>+    for (auto& parameter : functionDeclaration.parameters())
>+        checkErrorAndVisit(parameter);
>+    if (functionDeclaration.semantic())
>+        checkErrorAndVisit(*functionDeclaration.semantic());
>+}
>+
>+void Visitor::visit(AST::TypeArgument& typeArgument)
>+{
>+    WTF::visit(WTF::makeVisitor([&](AST::ConstantExpression& constantExpression) {
>+        checkErrorAndVisit(constantExpression);
>+    }, [&](UniqueRef<AST::TypeReference>& typeReference) {
>+        checkErrorAndVisit(static_cast<AST::TypeReference&>(typeReference));
>+    }), typeArgument);
>+}
>+
>+void Visitor::visit(AST::ReferenceType& referenceType)
>+{
>+    checkErrorAndVisit(referenceType.elementType());
>+}
>+
>+void Visitor::visit(AST::Semantic& semantic)
>+{
>+    WTF::visit(WTF::makeVisitor([&](AST::BuiltInSemantic& builtInSemantic) {
>+        checkErrorAndVisit(builtInSemantic);
>+    }, [&](AST::ResourceSemantic& resourceSemantic) {
>+        checkErrorAndVisit(resourceSemantic);
>+    }, [&](AST::SpecializationConstantSemantic& specializationConstantSemantic) {
>+        checkErrorAndVisit(specializationConstantSemantic);
>+    }, [&](AST::StageInOutSemantic& stageInOutSemantic) {
>+        checkErrorAndVisit(stageInOutSemantic);
>+    }), semantic);
>+}
>+
>+void Visitor::visit(AST::ConstantExpression& constantExpression)
>+{
>+    constantExpression.visit(WTF::makeVisitor([&](AST::IntegerLiteral& integerLiteral) {
>+        checkErrorAndVisit(integerLiteral);
>+    }, [&](AST::UnsignedIntegerLiteral& unsignedIntegerLiteral) {
>+        checkErrorAndVisit(unsignedIntegerLiteral);
>+    }, [&](AST::FloatLiteral& floatLiteral) {
>+        checkErrorAndVisit(floatLiteral);
>+    }, [&](AST::NullLiteral& nullLiteral) {
>+        checkErrorAndVisit(nullLiteral);
>+    }, [&](AST::BooleanLiteral& booleanLiteral) {
>+        checkErrorAndVisit(booleanLiteral);
>+    }, [&](AST::ConstantExpressionEnumerationMemberReference& constantExpressionEnumerationMemberReference) {
>+        checkErrorAndVisit(constantExpressionEnumerationMemberReference);
>+    }));
>+}
>+
>+void Visitor::visit(AST::AttributeBlock& attributeBlock)
>+{
>+    for (auto& functionAttribute : attributeBlock)
>+        checkErrorAndVisit(functionAttribute);
>+}
>+
>+void Visitor::visit(AST::BuiltInSemantic&)
>+{
>+}
>+
>+void Visitor::visit(AST::ResourceSemantic&)
>+{
>+}
>+
>+void Visitor::visit(AST::SpecializationConstantSemantic&)
>+{
>+}
>+
>+void Visitor::visit(AST::StageInOutSemantic&)
>+{
>+}
>+
>+void Visitor::visit(AST::IntegerLiteral& integerLiteral)
>+{
>+    checkErrorAndVisit(integerLiteral.type());
>+}
>+
>+void Visitor::visit(AST::UnsignedIntegerLiteral& unsignedIntegerLiteral)
>+{
>+    checkErrorAndVisit(unsignedIntegerLiteral.type());
>+}
>+
>+void Visitor::visit(AST::FloatLiteral& floatLiteral)
>+{
>+    checkErrorAndVisit(floatLiteral.type());
>+}
>+
>+void Visitor::visit(AST::NullLiteral& nullLiteral)
>+{
>+    checkErrorAndVisit(nullLiteral.type());
>+}
>+
>+void Visitor::visit(AST::BooleanLiteral&)
>+{
>+}
>+
>+void Visitor::visit(AST::IntegerLiteralType& integerLiteralType)
>+{
>+    if (integerLiteralType.resolvedType())
>+        checkErrorAndVisit(*integerLiteralType.resolvedType());
>+    checkErrorAndVisit(integerLiteralType.preferredType());
>+}
>+
>+void Visitor::visit(AST::UnsignedIntegerLiteralType& unsignedIntegerLiteralType)
>+{
>+    if (unsignedIntegerLiteralType.resolvedType())
>+        checkErrorAndVisit(*unsignedIntegerLiteralType.resolvedType());
>+    checkErrorAndVisit(unsignedIntegerLiteralType.preferredType());
>+}
>+
>+void Visitor::visit(AST::FloatLiteralType& floatLiteralType)
>+{
>+    if (floatLiteralType.resolvedType())
>+        checkErrorAndVisit(*floatLiteralType.resolvedType());
>+    checkErrorAndVisit(floatLiteralType.preferredType());
>+}
>+
>+void Visitor::visit(AST::NullLiteralType& nullLiteralType)
>+{
>+    if (nullLiteralType.resolvedType())
>+        checkErrorAndVisit(*nullLiteralType.resolvedType());
>+}
>+
>+void Visitor::visit(AST::ConstantExpressionEnumerationMemberReference&)
>+{
>+}
>+
>+void Visitor::visit(AST::FunctionAttribute& functionAttribute)
>+{
>+    WTF::visit(WTF::makeVisitor([&](AST::NumThreadsFunctionAttribute& numThreadsFunctionAttribute) {
>+        checkErrorAndVisit(numThreadsFunctionAttribute);
>+    }), functionAttribute);
>+}
>+
>+void Visitor::visit(AST::NumThreadsFunctionAttribute&)
>+{
>+}
>+
>+void Visitor::visit(AST::Block& block)
>+{
>+    for (auto& statement : block.statements())
>+        checkErrorAndVisit(static_cast<AST::Statement&>(statement));
>+}
>+
>+void Visitor::visit(AST::Statement& statement)
>+{
>+    if (is<AST::Block>(statement))
>+        checkErrorAndVisit(downcast<AST::Block>(statement));
>+    else if (is<AST::Break>(statement))
>+        checkErrorAndVisit(downcast<AST::Break>(statement));
>+    else if (is<AST::Continue>(statement))
>+        checkErrorAndVisit(downcast<AST::Continue>(statement));
>+    else if (is<AST::DoWhileLoop>(statement))
>+        checkErrorAndVisit(downcast<AST::DoWhileLoop>(statement));
>+    else if (is<AST::EffectfulExpressionStatement>(statement))
>+        checkErrorAndVisit(downcast<AST::EffectfulExpressionStatement>(statement));
>+    else if (is<AST::Fallthrough>(statement))
>+        checkErrorAndVisit(downcast<AST::Fallthrough>(statement));
>+    else if (is<AST::ForLoop>(statement))
>+        checkErrorAndVisit(downcast<AST::ForLoop>(statement));
>+    else if (is<AST::IfStatement>(statement))
>+        checkErrorAndVisit(downcast<AST::IfStatement>(statement));
>+    else if (is<AST::Return>(statement))
>+        checkErrorAndVisit(downcast<AST::Return>(statement));
>+    else if (is<AST::SwitchCase>(statement))
>+        checkErrorAndVisit(downcast<AST::SwitchCase>(statement));
>+    else if (is<AST::SwitchStatement>(statement))
>+        checkErrorAndVisit(downcast<AST::SwitchStatement>(statement));
>+    else if (is<AST::Trap>(statement))
>+        checkErrorAndVisit(downcast<AST::Trap>(statement));
>+    else if (is<AST::VariableDeclarationsStatement>(statement))
>+        checkErrorAndVisit(downcast<AST::VariableDeclarationsStatement>(statement));
>+    else {
>+        ASSERT(is<AST::WhileLoop>(statement));
>+        checkErrorAndVisit(downcast<AST::WhileLoop>(statement));
>+    }
>+}
>+
>+void Visitor::visit(AST::Break&)
>+{
>+}
>+
>+void Visitor::visit(AST::Continue&)
>+{
>+}
>+
>+void Visitor::visit(AST::DoWhileLoop& doWhileLoop)
>+{
>+    checkErrorAndVisit(doWhileLoop.body());
>+    checkErrorAndVisit(doWhileLoop.conditional());
>+}
>+
>+void Visitor::visit(AST::Expression& expression)
>+{
>+    if (is<AST::AssignmentExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::AssignmentExpression>(expression));
>+    else if (is<AST::BooleanLiteral>(expression))
>+        checkErrorAndVisit(downcast<AST::BooleanLiteral>(expression));
>+    else if (is<AST::CallExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::CallExpression>(expression));
>+    else if (is<AST::CommaExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::CommaExpression>(expression));
>+    else if (is<AST::DereferenceExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::DereferenceExpression>(expression));
>+    else if (is<AST::FloatLiteral>(expression))
>+        checkErrorAndVisit(downcast<AST::FloatLiteral>(expression));
>+    else if (is<AST::IntegerLiteral>(expression))
>+        checkErrorAndVisit(downcast<AST::IntegerLiteral>(expression));
>+    else if (is<AST::LogicalExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::LogicalExpression>(expression));
>+    else if (is<AST::LogicalNotExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::LogicalNotExpression>(expression));
>+    else if (is<AST::MakeArrayReferenceExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::MakeArrayReferenceExpression>(expression));
>+    else if (is<AST::MakePointerExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::MakePointerExpression>(expression));
>+    else if (is<AST::NullLiteral>(expression))
>+        checkErrorAndVisit(downcast<AST::NullLiteral>(expression));
>+    else if (is<AST::DotExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::DotExpression>(expression));
>+    else if (is<AST::IndexExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::IndexExpression>(expression));
>+    else if (is<AST::ReadModifyWriteExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::ReadModifyWriteExpression>(expression));
>+    else if (is<AST::TernaryExpression>(expression))
>+        checkErrorAndVisit(downcast<AST::TernaryExpression>(expression));
>+    else if (is<AST::UnsignedIntegerLiteral>(expression))
>+        checkErrorAndVisit(downcast<AST::UnsignedIntegerLiteral>(expression));
>+    else {
>+        ASSERT(is<AST::VariableReference>(expression));
>+        checkErrorAndVisit(downcast<AST::VariableReference>(expression));
>+    }
>+}
>+
>+void Visitor::visit(AST::DotExpression& dotExpression)
>+{
>+    checkErrorAndVisit(static_cast<AST::PropertyAccessExpression&>(dotExpression));
>+}
>+
>+void Visitor::visit(AST::IndexExpression& indexExpression)
>+{
>+    checkErrorAndVisit(indexExpression.indexExpression());
>+    checkErrorAndVisit(static_cast<AST::PropertyAccessExpression&>(indexExpression));
>+}
>+
>+void Visitor::visit(AST::PropertyAccessExpression& expression)
>+{
>+    checkErrorAndVisit(expression.base());
>+}
>+
>+void Visitor::visit(AST::EffectfulExpressionStatement& effectfulExpressionStatement)
>+{
>+    checkErrorAndVisit(effectfulExpressionStatement.effectfulExpression());
>+}
>+
>+void Visitor::visit(AST::Fallthrough&)
>+{
>+}
>+
>+void Visitor::visit(AST::ForLoop& forLoop)
>+{
>+    WTF::visit(WTF::makeVisitor([&](AST::VariableDeclarationsStatement& variableDeclarationsStatement) {
>+        checkErrorAndVisit(variableDeclarationsStatement);
>+    }, [&](UniqueRef<AST::Expression>& expression) {
>+        checkErrorAndVisit(static_cast<AST::Expression&>(expression));
>+    }), forLoop.initialization());
>+    if (forLoop.condition())
>+        checkErrorAndVisit(*forLoop.condition());
>+    if (forLoop.increment())
>+        checkErrorAndVisit(*forLoop.increment());
>+    checkErrorAndVisit(forLoop.body());
>+}
>+
>+void Visitor::visit(AST::IfStatement& ifStatement)
>+{
>+    checkErrorAndVisit(ifStatement.conditional());
>+    checkErrorAndVisit(ifStatement.body());
>+    if (ifStatement.elseBody())
>+        checkErrorAndVisit(static_cast<AST::Statement&>(*ifStatement.elseBody()));
>+}
>+
>+void Visitor::visit(AST::Return& returnStatement)
>+{
>+    if (returnStatement.value())
>+        checkErrorAndVisit(*returnStatement.value());
>+}
>+
>+void Visitor::visit(AST::SwitchCase& switchCase)
>+{
>+    if (switchCase.value())
>+        checkErrorAndVisit(*switchCase.value());
>+    checkErrorAndVisit(switchCase.block());
>+}
>+
>+void Visitor::visit(AST::SwitchStatement& switchStatement)
>+{
>+    checkErrorAndVisit(switchStatement.value());
>+    for (auto& switchCase : switchStatement.switchCases())
>+        checkErrorAndVisit(switchCase);
>+}
>+
>+void Visitor::visit(AST::Trap&)
>+{
>+}
>+
>+void Visitor::visit(AST::VariableDeclarationsStatement& variableDeclarationsStatement)
>+{
>+    for (auto& variableDeclaration : variableDeclarationsStatement.variableDeclarations())
>+        checkErrorAndVisit(variableDeclaration);
>+}
>+
>+void Visitor::visit(AST::WhileLoop& whileLoop)
>+{
>+    checkErrorAndVisit(whileLoop.conditional());
>+    checkErrorAndVisit(whileLoop.body());
>+}
>+
>+void Visitor::visit(AST::VariableDeclaration& variableDeclaration)
>+{
>+    if (variableDeclaration.type())
>+        checkErrorAndVisit(*variableDeclaration.type());
>+    if (variableDeclaration.semantic())
>+        checkErrorAndVisit(*variableDeclaration.semantic());
>+    if (variableDeclaration.initializer())
>+        checkErrorAndVisit(*variableDeclaration.initializer());
>+}
>+
>+void Visitor::visit(AST::AssignmentExpression& assignmentExpression)
>+{
>+    checkErrorAndVisit(assignmentExpression.left());
>+    checkErrorAndVisit(assignmentExpression.right());
>+}
>+
>+void Visitor::visit(AST::CallExpression& callExpression)
>+{
>+    for (auto& argument : callExpression.arguments())
>+        checkErrorAndVisit(static_cast<AST::Expression&>(argument));
>+    if (callExpression.castReturnType())
>+        checkErrorAndVisit(callExpression.castReturnType()->get());
>+}
>+
>+void Visitor::visit(AST::CommaExpression& commaExpression)
>+{
>+    for (auto& expression : commaExpression.list())
>+        checkErrorAndVisit(static_cast<AST::Expression&>(expression));
>+}
>+
>+void Visitor::visit(AST::DereferenceExpression& dereferenceExpression)
>+{
>+    checkErrorAndVisit(dereferenceExpression.pointer());
>+}
>+
>+void Visitor::visit(AST::LogicalExpression& logicalExpression)
>+{
>+    checkErrorAndVisit(logicalExpression.left());
>+    checkErrorAndVisit(logicalExpression.right());
>+}
>+
>+void Visitor::visit(AST::LogicalNotExpression& logicalNotExpression)
>+{
>+    checkErrorAndVisit(logicalNotExpression.operand());
>+}
>+
>+void Visitor::visit(AST::MakeArrayReferenceExpression& makeArrayReferenceExpression)
>+{
>+    checkErrorAndVisit(makeArrayReferenceExpression.lValue());
>+}
>+
>+void Visitor::visit(AST::MakePointerExpression& makePointerExpression)
>+{
>+    checkErrorAndVisit(makePointerExpression.lValue());
>+}
>+
>+void Visitor::visit(AST::ReadModifyWriteExpression& readModifyWriteExpression)
>+{
>+    checkErrorAndVisit(readModifyWriteExpression.lValue());
>+    checkErrorAndVisit(readModifyWriteExpression.oldValue());
>+    checkErrorAndVisit(readModifyWriteExpression.newValue());
>+    if (readModifyWriteExpression.newValueExpression())
>+        checkErrorAndVisit(*readModifyWriteExpression.newValueExpression());
>+    if (readModifyWriteExpression.resultExpression())
>+        checkErrorAndVisit(*readModifyWriteExpression.resultExpression());
>+}
>+
>+void Visitor::visit(AST::TernaryExpression& ternaryExpression)
>+{
>+    checkErrorAndVisit(ternaryExpression.predicate());
>+    checkErrorAndVisit(ternaryExpression.bodyExpression());
>+    checkErrorAndVisit(ternaryExpression.elseExpression());
>+}
>+
>+void Visitor::visit(AST::VariableReference&)
>+{
>+}
>+
>+void Visitor::checkErrorAndVisit(Program& program)
>+{
>+    if (!error())
>+        visit(program);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::UnnamedType& unnamedType)
>+{
>+    if (!error())
>+        visit(unnamedType);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::NamedType& namedType)
>+{
>+    if (!error())
>+        visit(namedType);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::TypeDefinition& typeDefinition)
>+{
>+    if (!error())
>+        visit(typeDefinition);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::StructureDefinition& structureDefinition)
>+{
>+    if (!error())
>+        visit(structureDefinition);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::EnumerationDefinition& enumerationDefinition)
>+{
>+    if (!error())
>+        visit(enumerationDefinition);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::FunctionDefinition& functionDefinition)
>+{
>+    if (!error())
>+        visit(functionDefinition);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::NativeFunctionDeclaration& nativeFunctionDeclaration)
>+{
>+    if (!error())
>+        visit(nativeFunctionDeclaration);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    if (!error())
>+        visit(nativeTypeDeclaration);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::TypeReference& typeReference)
>+{
>+    if (!error())
>+        visit(typeReference);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::PointerType& pointerType)
>+{
>+    if (!error())
>+        visit(pointerType);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::ArrayReferenceType& arrayReferenceType)
>+{
>+    if (!error())
>+        visit(arrayReferenceType);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::ArrayType& arrayType)
>+{
>+    if (!error())
>+        visit(arrayType);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::StructureElement& structureElement)
>+{
>+    if (!error())
>+        visit(structureElement);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::EnumerationMember& enumerationMember)
>+{
>+    if (!error())
>+        visit(enumerationMember);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::FunctionDeclaration& functionDeclaration)
>+{
>+    if (!error())
>+        visit(functionDeclaration);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::TypeArgument& typeArgument)
>+{
>+    if (!error())
>+        visit(typeArgument);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::ReferenceType& referenceType)
>+{
>+    if (!error())
>+        visit(referenceType);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::Semantic& semantic)
>+{
>+    if (!error())
>+        visit(semantic);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::ConstantExpression& constantExpression)
>+{
>+    if (!error())
>+        visit(constantExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::AttributeBlock& attributeBlock)
>+{
>+    if (!error())
>+        visit(attributeBlock);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::BuiltInSemantic& builtInSemantic)
>+{
>+    if (!error())
>+        visit(builtInSemantic);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::ResourceSemantic& resourceSemantic)
>+{
>+    if (!error())
>+        visit(resourceSemantic);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::SpecializationConstantSemantic& specializationConstantSemantic)
>+{
>+    if (!error())
>+        visit(specializationConstantSemantic);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::StageInOutSemantic& stageInOutSemantic)
>+{
>+    if (!error())
>+        visit(stageInOutSemantic);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::IntegerLiteral& integerLiteral)
>+{
>+    if (!error())
>+        visit(integerLiteral);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::UnsignedIntegerLiteral& unsignedIntegerLiteral)
>+{
>+    if (!error())
>+        visit(unsignedIntegerLiteral);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::FloatLiteral& floatLiteral)
>+{
>+    if (!error())
>+        visit(floatLiteral);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::NullLiteral& nullLiteral)
>+{
>+    if (!error())
>+        visit(nullLiteral);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::BooleanLiteral& booleanLiteral)
>+{
>+    if (!error())
>+        visit(booleanLiteral);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::IntegerLiteralType& integerLiteralType)
>+{
>+    if (!error())
>+        visit(integerLiteralType);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::UnsignedIntegerLiteralType& unsignedIntegerLiteralType)
>+{
>+    if (!error())
>+        visit(unsignedIntegerLiteralType);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::FloatLiteralType& floatLiteralType)
>+{
>+    if (!error())
>+        visit(floatLiteralType);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::NullLiteralType& nullLiteralType)
>+{
>+    if (!error())
>+        visit(nullLiteralType);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::ConstantExpressionEnumerationMemberReference& constantExpressionEnumerationMemberReference)
>+{
>+    if (!error())
>+        visit(constantExpressionEnumerationMemberReference);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::FunctionAttribute& functionAttribute)
>+{
>+    if (!error())
>+        visit(functionAttribute);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::NumThreadsFunctionAttribute& numThreadsFunctionAttribute)
>+{
>+    if (!error())
>+        visit(numThreadsFunctionAttribute);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::Block& block)
>+{
>+    if (!error())
>+        visit(block);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::Statement& statement)
>+{
>+    if (!error())
>+        visit(statement);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::Break& breakStatement)
>+{
>+    if (!error())
>+        visit(breakStatement);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::Continue& continueStatement)
>+{
>+    if (!error())
>+        visit(continueStatement);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::DoWhileLoop& doWhileLoop)
>+{
>+    if (!error())
>+        visit(doWhileLoop);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::Expression& expression)
>+{
>+    if (!error())
>+        visit(expression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::DotExpression& dotExpression)
>+{
>+    if (!error())
>+        visit(dotExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::IndexExpression& indexExpression)
>+{
>+    if (!error())
>+        visit(indexExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::PropertyAccessExpression& propertyAccessExpression)
>+{
>+    if (!error())
>+        visit(propertyAccessExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::EffectfulExpressionStatement& effectfulExpressionStatement)
>+{
>+    if (!error())
>+        visit(effectfulExpressionStatement);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::Fallthrough& fallthroughStatement)
>+{
>+    if (!error())
>+        visit(fallthroughStatement);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::ForLoop& forLoop)
>+{
>+    if (!error())
>+        visit(forLoop);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::IfStatement& ifStatement)
>+{
>+    if (!error())
>+        visit(ifStatement);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::Return& returnStatement)
>+{
>+    if (!error())
>+        visit(returnStatement);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::SwitchCase& switchCase)
>+{
>+    if (!error())
>+        visit(switchCase);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::SwitchStatement& switchStatement)
>+{
>+    if (!error())
>+        visit(switchStatement);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::Trap& trap)
>+{
>+    if (!error())
>+        visit(trap);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::VariableDeclarationsStatement& variableDeclarationsStatement)
>+{
>+    if (!error())
>+        visit(variableDeclarationsStatement);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::WhileLoop& whileLoop)
>+{
>+    if (!error())
>+        visit(whileLoop);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::VariableDeclaration& variableDeclaration)
>+{
>+    if (!error())
>+        visit(variableDeclaration);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::AssignmentExpression& assignmentExpression)
>+{
>+    if (!error())
>+        visit(assignmentExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::CallExpression& callExpression)
>+{
>+    if (!error())
>+        visit(callExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::CommaExpression& commaExpression)
>+{
>+    if (!error())
>+        visit(commaExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::DereferenceExpression& dereferenceExpression)
>+{
>+    if (!error())
>+        visit(dereferenceExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::LogicalExpression& logicalExpression)
>+{
>+    if (!error())
>+        visit(logicalExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::LogicalNotExpression& logicalNotExpression)
>+{
>+    if (!error())
>+        visit(logicalNotExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::MakeArrayReferenceExpression& makeArrayReferenceExpression)
>+{
>+    if (!error())
>+        visit(makeArrayReferenceExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::MakePointerExpression& makePointerExpression)
>+{
>+    if (!error())
>+        visit(makePointerExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::ReadModifyWriteExpression& readModifyWriteExpression)
>+{
>+    if (!error())
>+        visit(readModifyWriteExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::TernaryExpression& ternaryExpression)
>+{
>+    if (!error())
>+        visit(ternaryExpression);
>+}
>+
>+void Visitor::checkErrorAndVisit(AST::VariableReference& variableReference)
>+{
>+    if (!error())
>+        visit(variableReference);
>+}
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..9a3f6261c35727d0b641c2b89a0bb495f15d2ca3
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h
>@@ -0,0 +1,264 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLFunctionAttribute.h"
>+#include "WHLSLSemantic.h"
>+#include "WHLSLTypeArgument.h"
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+class Program;
>+
>+namespace AST {
>+
>+class TypeDefinition;
>+class StructureDefinition;
>+class EnumerationDefinition;
>+class FunctionDefinition;
>+class NativeFunctionDeclaration;
>+class NativeTypeDeclaration;
>+class TypeReference;
>+class PointerType;
>+class ArrayReferenceType;
>+class ArrayType;
>+class StructureElement;
>+class EnumerationMember;
>+class FunctionDeclaration;
>+class ReferenceType;
>+class ConstantExpression;
>+class BuiltInSemantic;
>+class ResourceSemantic;
>+class SpecializationConstantSemantic;
>+class StageInOutSemantic;
>+class IntegerLiteral;
>+class UnsignedIntegerLiteral;
>+class FloatLiteral;
>+class NullLiteral;
>+class BooleanLiteral;
>+class ConstantExpressionEnumerationMemberReference;
>+class NumThreadsFunctionAttribute;
>+class Block;
>+class Statement;
>+class Break;
>+class Continue;
>+class DoWhileLoop;
>+class Expression;
>+class DotExpression;
>+class IndexExpression;
>+class PropertyAccessExpression;
>+class EffectfulExpressionStatement;
>+class Fallthrough;
>+class ForLoop;
>+class IfStatement;
>+class Return;
>+class SwitchCase;
>+class SwitchStatement;
>+class Trap;
>+class VariableDeclarationsStatement;
>+class WhileLoop;
>+class VariableDeclaration;
>+class AssignmentExpression;
>+class CallExpression;
>+class CommaExpression;
>+class DereferenceExpression;
>+class LogicalExpression;
>+class LogicalNotExpression;
>+class MakeArrayReferenceExpression;
>+class MakePointerExpression;
>+class ReadModifyWriteExpression;
>+class TernaryExpression;
>+class VariableReference;
>+class UnnamedType;
>+class NamedType;
>+
>+}
>+
>+class Visitor {
>+public:
>+    virtual ~Visitor() = default;
>+
>+    // FIXME: Add a way to visit a const Program
>+
>+    virtual void visit(Program&);
>+    virtual void visit(AST::UnnamedType&);
>+    virtual void visit(AST::NamedType&);
>+    virtual void visit(AST::TypeDefinition&);
>+    virtual void visit(AST::StructureDefinition&);
>+    virtual void visit(AST::EnumerationDefinition&);
>+    virtual void visit(AST::FunctionDefinition&);
>+    virtual void visit(AST::NativeFunctionDeclaration&);
>+    virtual void visit(AST::NativeTypeDeclaration&);
>+    virtual void visit(AST::TypeReference&);
>+    virtual void visit(AST::PointerType&);
>+    virtual void visit(AST::ArrayReferenceType&);
>+    virtual void visit(AST::ArrayType&);
>+    virtual void visit(AST::StructureElement&);
>+    virtual void visit(AST::EnumerationMember&);
>+    virtual void visit(AST::FunctionDeclaration&);
>+    virtual void visit(AST::TypeArgument&);
>+    virtual void visit(AST::ReferenceType&);
>+    virtual void visit(AST::Semantic&);
>+    virtual void visit(AST::ConstantExpression&);
>+    virtual void visit(AST::AttributeBlock&);
>+    virtual void visit(AST::BuiltInSemantic&);
>+    virtual void visit(AST::ResourceSemantic&);
>+    virtual void visit(AST::SpecializationConstantSemantic&);
>+    virtual void visit(AST::StageInOutSemantic&);
>+    virtual void visit(AST::IntegerLiteral&);
>+    virtual void visit(AST::UnsignedIntegerLiteral&);
>+    virtual void visit(AST::FloatLiteral&);
>+    virtual void visit(AST::NullLiteral&);
>+    virtual void visit(AST::BooleanLiteral&);
>+    virtual void visit(AST::IntegerLiteralType&);
>+    virtual void visit(AST::UnsignedIntegerLiteralType&);
>+    virtual void visit(AST::FloatLiteralType&);
>+    virtual void visit(AST::NullLiteralType&);
>+    virtual void visit(AST::ConstantExpressionEnumerationMemberReference&);
>+    virtual void visit(AST::FunctionAttribute&);
>+    virtual void visit(AST::NumThreadsFunctionAttribute&);
>+    virtual void visit(AST::Block&);
>+    virtual void visit(AST::Statement&);
>+    virtual void visit(AST::Break&);
>+    virtual void visit(AST::Continue&);
>+    virtual void visit(AST::DoWhileLoop&);
>+    virtual void visit(AST::Expression&);
>+    virtual void visit(AST::DotExpression&);
>+    virtual void visit(AST::IndexExpression&);
>+    virtual void visit(AST::PropertyAccessExpression&);
>+    virtual void visit(AST::EffectfulExpressionStatement&);
>+    virtual void visit(AST::Fallthrough&);
>+    virtual void visit(AST::ForLoop&);
>+    virtual void visit(AST::IfStatement&);
>+    virtual void visit(AST::Return&);
>+    virtual void visit(AST::SwitchCase&);
>+    virtual void visit(AST::SwitchStatement&);
>+    virtual void visit(AST::Trap&);
>+    virtual void visit(AST::VariableDeclarationsStatement&);
>+    virtual void visit(AST::WhileLoop&);
>+    virtual void visit(AST::VariableDeclaration&);
>+    virtual void visit(AST::AssignmentExpression&);
>+    virtual void visit(AST::CallExpression&);
>+    virtual void visit(AST::CommaExpression&);
>+    virtual void visit(AST::DereferenceExpression&);
>+    virtual void visit(AST::LogicalExpression&);
>+    virtual void visit(AST::LogicalNotExpression&);
>+    virtual void visit(AST::MakeArrayReferenceExpression&);
>+    virtual void visit(AST::MakePointerExpression&);
>+    virtual void visit(AST::ReadModifyWriteExpression&);
>+    virtual void visit(AST::TernaryExpression&);
>+    virtual void visit(AST::VariableReference&);
>+
>+    void checkErrorAndVisit(Program&);
>+    void checkErrorAndVisit(AST::UnnamedType&);
>+    void checkErrorAndVisit(AST::NamedType&);
>+    void checkErrorAndVisit(AST::TypeDefinition&);
>+    void checkErrorAndVisit(AST::StructureDefinition&);
>+    void checkErrorAndVisit(AST::EnumerationDefinition&);
>+    void checkErrorAndVisit(AST::FunctionDefinition&);
>+    void checkErrorAndVisit(AST::NativeFunctionDeclaration&);
>+    void checkErrorAndVisit(AST::NativeTypeDeclaration&);
>+    void checkErrorAndVisit(AST::TypeReference&);
>+    void checkErrorAndVisit(AST::PointerType&);
>+    void checkErrorAndVisit(AST::ArrayReferenceType&);
>+    void checkErrorAndVisit(AST::ArrayType&);
>+    void checkErrorAndVisit(AST::StructureElement&);
>+    void checkErrorAndVisit(AST::EnumerationMember&);
>+    void checkErrorAndVisit(AST::FunctionDeclaration&);
>+    void checkErrorAndVisit(AST::TypeArgument&);
>+    void checkErrorAndVisit(AST::ReferenceType&);
>+    void checkErrorAndVisit(AST::Semantic&);
>+    void checkErrorAndVisit(AST::ConstantExpression&);
>+    void checkErrorAndVisit(AST::AttributeBlock&);
>+    void checkErrorAndVisit(AST::BuiltInSemantic&);
>+    void checkErrorAndVisit(AST::ResourceSemantic&);
>+    void checkErrorAndVisit(AST::SpecializationConstantSemantic&);
>+    void checkErrorAndVisit(AST::StageInOutSemantic&);
>+    void checkErrorAndVisit(AST::IntegerLiteral&);
>+    void checkErrorAndVisit(AST::UnsignedIntegerLiteral&);
>+    void checkErrorAndVisit(AST::FloatLiteral&);
>+    void checkErrorAndVisit(AST::NullLiteral&);
>+    void checkErrorAndVisit(AST::BooleanLiteral&);
>+    void checkErrorAndVisit(AST::IntegerLiteralType&);
>+    void checkErrorAndVisit(AST::UnsignedIntegerLiteralType&);
>+    void checkErrorAndVisit(AST::FloatLiteralType&);
>+    void checkErrorAndVisit(AST::NullLiteralType&);
>+    void checkErrorAndVisit(AST::ConstantExpressionEnumerationMemberReference&);
>+    void checkErrorAndVisit(AST::FunctionAttribute&);
>+    void checkErrorAndVisit(AST::NumThreadsFunctionAttribute&);
>+    void checkErrorAndVisit(AST::Block&);
>+    void checkErrorAndVisit(AST::Statement&);
>+    void checkErrorAndVisit(AST::Break&);
>+    void checkErrorAndVisit(AST::Continue&);
>+    void checkErrorAndVisit(AST::DoWhileLoop&);
>+    void checkErrorAndVisit(AST::Expression&);
>+    void checkErrorAndVisit(AST::DotExpression&);
>+    void checkErrorAndVisit(AST::IndexExpression&);
>+    void checkErrorAndVisit(AST::PropertyAccessExpression&);
>+    void checkErrorAndVisit(AST::EffectfulExpressionStatement&);
>+    void checkErrorAndVisit(AST::Fallthrough&);
>+    void checkErrorAndVisit(AST::ForLoop&);
>+    void checkErrorAndVisit(AST::IfStatement&);
>+    void checkErrorAndVisit(AST::Return&);
>+    void checkErrorAndVisit(AST::SwitchCase&);
>+    void checkErrorAndVisit(AST::SwitchStatement&);
>+    void checkErrorAndVisit(AST::Trap&);
>+    void checkErrorAndVisit(AST::VariableDeclarationsStatement&);
>+    void checkErrorAndVisit(AST::WhileLoop&);
>+    void checkErrorAndVisit(AST::VariableDeclaration&);
>+    void checkErrorAndVisit(AST::AssignmentExpression&);
>+    void checkErrorAndVisit(AST::CallExpression&);
>+    void checkErrorAndVisit(AST::CommaExpression&);
>+    void checkErrorAndVisit(AST::DereferenceExpression&);
>+    void checkErrorAndVisit(AST::LogicalExpression&);
>+    void checkErrorAndVisit(AST::LogicalNotExpression&);
>+    void checkErrorAndVisit(AST::MakeArrayReferenceExpression&);
>+    void checkErrorAndVisit(AST::MakePointerExpression&);
>+    void checkErrorAndVisit(AST::ReadModifyWriteExpression&);
>+    void checkErrorAndVisit(AST::TernaryExpression&);
>+    void checkErrorAndVisit(AST::VariableReference&);
>+
>+    void setError()
>+    {
>+        ASSERT(!m_error);
>+        m_error = true;
>+    }
>+
>+    bool error() const { return m_error; }
>+
>+private:
>+    bool m_error { false }; // FIXME: Migrate this to be some sort of descriptive string.
>+};
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Sources.txt b/Source/WebCore/Sources.txt
>index 12a9244c78f5a5575e21b034e5d21377440acf80..e380302c03905abc039f1276e0d2d2c012ed3edc 100644
>--- a/Source/WebCore/Sources.txt
>+++ b/Source/WebCore/Sources.txt
>@@ -308,6 +308,7 @@ Modules/websockets/WorkerThreadableWebSocketChannel.cpp
> Modules/webgpu/DOMWindowWebGPU.cpp
> Modules/webgpu/WHLSL/WHLSLLexer.cpp
> Modules/webgpu/WHLSL/WHLSLParser.cpp
>+Modules/webgpu/WHLSL/WHLSLVisitor.cpp
> Modules/webgpu/WHLSL/AST/WHLSLTypeArgument.cpp
> Modules/webgpu/WHLSL/AST/WHLSLBuiltInSemantic.cpp
> Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.cpp
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index 915d5441a50b47f0b0e3ba8d139998ec94bf5e23..a13255c0a9b979101e5565add37991e31337c93b 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -13318,6 +13318,8 @@
> 		C21BF74521CD969800227979 /* WHLSLStandardLibrary.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = WHLSLStandardLibrary.txt; sourceTree = "<group>"; };
> 		C21DF2E71D9E4E9900F5B24C /* CSSFontVariationValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontVariationValue.cpp; sourceTree = "<group>"; };
> 		C21DF2E81D9E4E9900F5B24C /* CSSFontVariationValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontVariationValue.h; sourceTree = "<group>"; };
>+		C234A98521E886A9003C984D /* WHLSLVisitor.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLVisitor.cpp; sourceTree = "<group>"; };
>+		C234A98721E886AD003C984D /* WHLSLVisitor.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLVisitor.h; sourceTree = "<group>"; };
> 		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>"; };
>@@ -19669,7 +19671,6 @@
> 		656580EC09D12B20000E61D7 /* Derived Sources */ = {
> 			isa = PBXGroup;
> 			children = (
>-				C21BF74221CD963B00227979 /* WHLSLStandardLibrary.h */,
> 				538EC7EA1F96A95B004D22A8 /* unified-sources */,
> 				9908B0F31BCACFFE00ED0F65 /* ByteLengthQueuingStrategyBuiltins.cpp */,
> 				9908B0F51BCAD07D00ED0F65 /* ByteLengthQueuingStrategyBuiltins.h */,
>@@ -19759,6 +19760,7 @@
> 				656581AF09D14EE6000E61D7 /* UserAgentStyleSheetsData.cpp */,
> 				1A1414B313A0F0500019996C /* WebKitFontFamilyNames.cpp */,
> 				1A1414B413A0F0500019996C /* WebKitFontFamilyNames.h */,
>+				C21BF74221CD963B00227979 /* WHLSLStandardLibrary.h */,
> 				51748FA21CC6EEEB00728D84 /* WorkerGlobalScopeConstructors.idl */,
> 				9908B0F91BCAD07D00ED0F75 /* WritableStreamBuiltins.cpp */,
> 				9B03D8061BB3110D00B764E8 /* WritableStreamBuiltins.h */,
>@@ -25375,13 +25377,15 @@
> 		C210E90D21B4BCA400B7F83D /* WHLSL */ = {
> 			isa = PBXGroup;
> 			children = (
>-				C21BF74521CD969800227979 /* WHLSLStandardLibrary.txt */,
> 				C21BF6F121CD898D00227979 /* AST */,
> 				C210E91121B4BD1000B7F83D /* WHLSLLexer.cpp */,
> 				C210E91221B4BD1000B7F83D /* WHLSLLexer.h */,
> 				C21BF73721CD8A0200227979 /* WHLSLParser.cpp */,
> 				C21BF73821CD8A0300227979 /* WHLSLParser.h */,
> 				C21BF73A21CD8D7000227979 /* WHLSLProgram.h */,
>+				C21BF74521CD969800227979 /* WHLSLStandardLibrary.txt */,
>+				C234A98521E886A9003C984D /* WHLSLVisitor.cpp */,
>+				C234A98721E886AD003C984D /* WHLSLVisitor.h */,
> 			);
> 			path = WHLSL;
> 			sourceTree = "<group>";

Actions: View | Formatted Diff | Diff

Attachments on bug 192826: 357603 | 357930 | 358011 | 358882 | 358911