Attachment 373449 Details for Bug 199289 – WIP

[patch] WIP

b-backup.diff (text/plain), 26.81 KB, created by Saam Barati on 2019-07-03 19:31:22 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Saam Barati

Created: 2019-07-03 19:31:22 PDT

Size: 26.81 KB

patch

obsolete

>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp	(revision 247086)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp	(working copy)
>@@ -63,6 +63,8 @@
> #include <wtf/Vector.h>
> #include <wtf/text/WTFString.h>
> 
>+#include "WHLSLASTDumper.h"
>+
> namespace WebCore {
> 
> namespace WHLSL {
>@@ -177,7 +179,11 @@ static Optional<AST::NativeFunctionDecla
>         bool secondArgumentIsUint = types[1].get().visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& unnamedType) -> bool {
>             return matches(unnamedType, intrinsics.uintType());
>         }, [&](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> bool {
>-            return resolvableTypeReference->resolvableType().canResolve(intrinsics.uintType());
>+            bool ok = true;
>+            resolvableTypeReference->forEachType([&] (AST::ResolvableType& type) {
>+                ok &= type.canResolve(intrinsics.uintType());
>+            });
>+            return ok;
>         }));
>         if (firstArgumentArrayRef && secondArgumentIsUint)
>             return resolveWithOperatorAnderIndexer(origin, *firstArgumentArrayRef, intrinsics);
>@@ -196,7 +202,11 @@ static Optional<AST::NativeFunctionDecla
>             return resolvingType.visit(WTF::makeVisitor([](UniqueRef<AST::UnnamedType>& unnamedType) -> Acceptability {
>                 return is<AST::ReferenceType>(static_cast<AST::UnnamedType&>(unnamedType)) ? Acceptability::Yes : Acceptability::No;
>             }, [](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> Acceptability {
>-                return is<AST::NullLiteralType>(resolvableTypeReference->resolvableType()) ? Acceptability::Maybe : Acceptability::No;
>+                bool isAcceptable = true;
>+                resolvableTypeReference->forEachType([&] (AST::ResolvableType& type) {
>+                    isAcceptable &= is<AST::NullLiteralType>(type);
>+                });
>+                return isAcceptable ? Acceptability::Maybe : Acceptability::No;
>             }));
>         };
>         auto leftAcceptability = acceptability(types[0].get());
>@@ -469,8 +479,9 @@ private:
>     Optional<RecurseInfo> getInfo(AST::Expression&, bool requiresLeftValue = false);
>     Optional<UniqueRef<AST::UnnamedType>> recurseAndWrapBaseType(AST::PropertyAccessExpression&);
>     bool recurseAndRequireBoolType(AST::Expression&);
>-    void assignType(AST::Expression&, UniqueRef<AST::UnnamedType>&&, AST::TypeAnnotation);
>-    void assignType(AST::Expression&, RefPtr<ResolvableTypeReference>&&, AST::TypeAnnotation);
>+    void assignType(AST::Expression&, UniqueRef<AST::UnnamedType>&&, AST::TypeAnnotation = AST::RightValue());
>+    void assignType(AST::Expression&, RefPtr<ResolvableTypeReference>&&, AST::TypeAnnotation = AST::RightValue());
>+    void assignType(AST::Expression&, ResolvingType, AST::TypeAnnotation = AST::RightValue());
>     void forwardType(AST::Expression&, ResolvingType&, AST::TypeAnnotation);
> 
>     void visit(AST::FunctionDefinition&) override;
>@@ -534,18 +545,84 @@ void Checker::visit(Program& program)
>         checkErrorAndVisit(program.nativeFunctionDeclarations()[i]);
> }
> 
>+static Optional<UniqueRef<AST::UnnamedType>> commit(AST::Expression& expr, RefPtr<ResolvableTypeReference>& resolvableTypeReference)
>+{
>+    dataLogLn("---------------");
>+    dataLogLn(ExpressionDumper(expr));
>+    auto& root = resolvableTypeReference->root();
>+    dataLogLn("Root: ", RawPointer(&root));
>+
>+    AST::ResolvableType* preferredLiteralType = nullptr;
>+    AST::UnnamedType* resolvedType = nullptr;
>+
>+    bool sawNullLiteralType = false;
>+    root.forEachType([&] (AST::ResolvableType& type) {
>+        if (type.maybeResolvedType())
>+            resolvedType = type.maybeResolvedType();
>+        sawNullLiteralType |= is<AST::NullLiteralType>(type);
>+
>+        if (!preferredLiteralType) {
>+            preferredLiteralType = &type;
>+            return;
>+        }
>+        
>+        if (is<AST::FloatLiteralType>(type)) {
>+            preferredLiteralType = &type;
>+            return;
>+        }
>+
>+        if (is<AST::UnsignedIntegerLiteralType>(*preferredLiteralType) && is<AST::IntegerLiteralType>(type))
>+            preferredLiteralType = &type;
>+    });
>+
>+    if (sawNullLiteralType)
>+        return WTF::nullopt;
>+
>+    AST::UnnamedType* preferredType;
>+    if (is<AST::FloatLiteralType>(*preferredLiteralType)) {
>+        preferredType = &downcast<AST::FloatLiteralType>(*preferredLiteralType).preferredType();
>+        dataLogLn("Preferred type is float!");
>+    } else if (is<AST::UnsignedIntegerLiteralType>(*preferredLiteralType)) {
>+        preferredType = &downcast<AST::UnsignedIntegerLiteralType>(*preferredLiteralType).preferredType();
>+        dataLogLn("Preferred type is unsigned!");
>+    } else if (is<AST::IntegerLiteralType>(*preferredLiteralType)) {
>+        preferredType = &downcast<AST::IntegerLiteralType>(*preferredLiteralType).preferredType();
>+        dataLogLn("Preferred type is integer: ", RawPointer(&preferredType->unifyNode()));
>+    } else
>+        RELEASE_ASSERT_NOT_REACHED();
>+
>+    if (resolvedType)
>+        preferredType = resolvedType;
>+
>+    bool ok = true;
>+    root.forEachType([&] (AST::ResolvableType& type) {
>+        if (type.maybeResolvedType()) {
>+            if (!matches(*preferredType, *type.maybeResolvedType())) {
>+                dataLogLn("Not matches!!");
>+                dataLogLn("resolved type: ", TypeDumper(*type.maybeResolvedType()) );
>+                ok = false;
>+            } else {
>+                dataLogLn("Matches!");
>+            }
>+        } else if (!matchAndCommit(*preferredType, type))
>+            ok = false;
>+    });
>+
>+    return ok ? Optional<UniqueRef<AST::UnnamedType>>(preferredType->clone()) : WTF::nullopt;
>+}
>+
> bool Checker::assignTypes()
> {
>+    dataLogLn("ASSIGN TYPES");
>     for (auto& keyValuePair : m_typeMap) {
>         auto success = keyValuePair.value->visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& unnamedType) -> bool {
>             keyValuePair.key->setType(unnamedType->clone());
>             return true;
>         }, [&](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> bool {
>-            if (!resolvableTypeReference->resolvableType().maybeResolvedType()) {
>-                if (!static_cast<bool>(commit(resolvableTypeReference->resolvableType())))
>-                    return false;
>-            }
>-            keyValuePair.key->setType(resolvableTypeReference->resolvableType().resolvedType().clone());
>+            auto resolvedType = commit(*keyValuePair.key, resolvableTypeReference);
>+            if (!resolvedType)
>+                return false;
>+            keyValuePair.key->setType(WTFMove(resolvedType.value()));
>             return true;
>         }));
>         if (!success)
>@@ -594,21 +671,40 @@ void Checker::visit(AST::FunctionDefinit
>     Visitor::visit(functionDefinition);
> }
> 
>-static Optional<UniqueRef<AST::UnnamedType>> matchAndCommit(ResolvingType& left, ResolvingType& right)
>+template <typename Type>
>+static Optional<UniqueRef<AST::UnnamedType>> matchAndCommit(RefPtr<ResolvableTypeReference>& resolvableTypeReference, Type& matchingType)
>+{
>+    static_assert(std::is_same<Type, AST::NamedType>::value || std::is_same<Type, AST::UnnamedType>::value, "");
>+    Optional<UniqueRef<AST::UnnamedType>> result;
>+    bool ok = true;
>+    resolvableTypeReference->forEachType([&] (AST::ResolvableType& type) {
>+        result = matchAndCommit(matchingType, type);
>+        ok &= !!result;
>+    });
>+    return ok ? WTFMove(result) : WTF::nullopt;
>+}
>+static Optional<ResolvingType> matchAndCommit(ResolvingType& left, ResolvingType& right)
> {
>-    return left.visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& left) -> Optional<UniqueRef<AST::UnnamedType>> {
>-        return right.visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& right) -> Optional<UniqueRef<AST::UnnamedType>> {
>+    return left.visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& left) -> Optional<ResolvingType> {
>+        return right.visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& right) -> Optional<ResolvingType> {
>             if (matches(left, right))
>-                return left->clone();
>+                return ResolvingType(left->clone());
>+            return WTF::nullopt;
>+        }, [&](RefPtr<ResolvableTypeReference>& right) -> Optional<ResolvingType> {
>+            if (auto result = matchAndCommit(right, left.get()))
>+                return ResolvingType(WTFMove(result.value()));
>             return WTF::nullopt;
>-        }, [&](RefPtr<ResolvableTypeReference>& right) -> Optional<UniqueRef<AST::UnnamedType>> {
>-            return matchAndCommit(left, right->resolvableType());
>         }));
>-    }, [&](RefPtr<ResolvableTypeReference>& left) -> Optional<UniqueRef<AST::UnnamedType>> {
>-        return right.visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& right) -> Optional<UniqueRef<AST::UnnamedType>> {
>-            return matchAndCommit(right, left->resolvableType());
>-        }, [&](RefPtr<ResolvableTypeReference>& right) -> Optional<UniqueRef<AST::UnnamedType>> {
>-            return matchAndCommit(left->resolvableType(), right->resolvableType());
>+    }, [&](RefPtr<ResolvableTypeReference>& left) -> Optional<ResolvingType> {
>+        return right.visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& right) -> Optional<ResolvingType> {
>+            if (auto result = matchAndCommit(left, right.get()))
>+                return ResolvingType(WTFMove(result.value()));
>+            return WTF::nullopt;
>+        }, [&](RefPtr<ResolvableTypeReference>& right) -> Optional<ResolvingType> {
>+            auto* result = new ResolvableTypeReference(left, right);
>+            left->setParent(*result);
>+            right->setParent(*result);
>+            return ResolvingType(adoptRef(result));
>         }));
>     }));
> }
>@@ -619,8 +715,8 @@ static Optional<UniqueRef<AST::UnnamedTy
>         if (matches(unnamedType, resolvingType))
>             return unnamedType.clone();
>         return WTF::nullopt;
>-    }, [&](RefPtr<ResolvableTypeReference>& resolvingType) -> Optional<UniqueRef<AST::UnnamedType>> {
>-        return matchAndCommit(unnamedType, resolvingType->resolvableType());
>+    }, [&](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> Optional<UniqueRef<AST::UnnamedType>> {
>+        return matchAndCommit(resolvableTypeReference, unnamedType);
>     }));
> }
> 
>@@ -630,19 +726,17 @@ static Optional<UniqueRef<AST::UnnamedTy
>         if (matches(resolvingType, namedType))
>             return resolvingType->clone();
>         return WTF::nullopt;
>-    }, [&](RefPtr<ResolvableTypeReference>& resolvingType) -> Optional<UniqueRef<AST::UnnamedType>> {
>-        return matchAndCommit(namedType, resolvingType->resolvableType());
>+    }, [&](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> Optional<UniqueRef<AST::UnnamedType>> {
>+        return matchAndCommit(resolvableTypeReference, namedType);
>     }));
> }
> 
>-static Optional<UniqueRef<AST::UnnamedType>> commit(ResolvingType& resolvingType)
>+static Optional<UniqueRef<AST::UnnamedType>> commit(AST::Expression& expr, ResolvingType& resolvingType)
> {
>     return resolvingType.visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& unnamedType) -> Optional<UniqueRef<AST::UnnamedType>> {
>         return unnamedType->clone();
>     }, [&](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> Optional<UniqueRef<AST::UnnamedType>> {
>-        if (!resolvableTypeReference->resolvableType().maybeResolvedType())
>-            return commit(resolvableTypeReference->resolvableType());
>-        return resolvableTypeReference->resolvableType().resolvedType().clone();
>+        return commit(expr, resolvableTypeReference);
>     }));
> }
> 
>@@ -800,7 +894,7 @@ void Checker::visit(AST::VariableDeclara
>     }
> }
> 
>-void Checker::assignType(AST::Expression& expression, UniqueRef<AST::UnnamedType>&& unnamedType, AST::TypeAnnotation typeAnnotation = AST::RightValue())
>+void Checker::assignType(AST::Expression& expression, UniqueRef<AST::UnnamedType>&& unnamedType, AST::TypeAnnotation typeAnnotation)
> {
>     auto addResult = m_typeMap.add(&expression, std::make_unique<ResolvingType>(WTFMove(unnamedType)));
>     ASSERT_UNUSED(addResult, addResult.isNewEntry);
>@@ -808,7 +902,7 @@ void Checker::assignType(AST::Expression
>     ASSERT_UNUSED(typeAnnotationAddResult, typeAnnotationAddResult.isNewEntry);
> }
> 
>-void Checker::assignType(AST::Expression& expression, RefPtr<ResolvableTypeReference>&& resolvableTypeReference, AST::TypeAnnotation typeAnnotation = AST::RightValue())
>+void Checker::assignType(AST::Expression& expression, RefPtr<ResolvableTypeReference>&& resolvableTypeReference, AST::TypeAnnotation typeAnnotation)
> {
>     auto addResult = m_typeMap.add(&expression, std::make_unique<ResolvingType>(WTFMove(resolvableTypeReference)));
>     ASSERT_UNUSED(addResult, addResult.isNewEntry);
>@@ -816,6 +910,15 @@ void Checker::assignType(AST::Expression
>     ASSERT_UNUSED(typeAnnotationAddResult, typeAnnotationAddResult.isNewEntry);
> }
> 
>+void Checker::assignType(AST::Expression& expression, ResolvingType resolvingType, AST::TypeAnnotation typeAnnotation)
>+{
>+    return resolvingType.visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& left) {
>+        assignType(expression, WTFMove(left), typeAnnotation);
>+    }, [&](RefPtr<ResolvableTypeReference>& left) {
>+        assignType(expression, WTFMove(left), typeAnnotation);
>+    }));
>+}
>+
> void Checker::forwardType(AST::Expression& expression, ResolvingType& resolvingType, AST::TypeAnnotation typeAnnotation = AST::RightValue())
> {
>     resolvingType.visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& result) {
>@@ -844,7 +947,7 @@ void Checker::visit(AST::AssignmentExpre
>     if (!rightInfo)
>         return;
> 
>-    auto resultType = matchAndCommit(leftInfo->resolvingType, rightInfo->resolvingType);
>+    auto resultType = matchAndCommit(rightInfo->resolvingType, *leftInfo->resolvingType.getUnnamedType());
>     if (!resultType) {
>         setError();
>         return;
>@@ -865,7 +968,7 @@ void Checker::visit(AST::ReadModifyWrite
>     if (!newValueInfo)
>         return;
> 
>-    if (Optional<UniqueRef<AST::UnnamedType>> matchedType = matchAndCommit(leftValueInfo->resolvingType, newValueInfo->resolvingType))
>+    if (Optional<UniqueRef<AST::UnnamedType>> matchedType = matchAndCommit(newValueInfo->resolvingType, *leftValueInfo->resolvingType.getUnnamedType()))
>         readModifyWriteExpression.newValue().setType(WTFMove(matchedType.value()));
>     else {
>         setError();
>@@ -883,9 +986,23 @@ static AST::UnnamedType* getUnnamedType(
> {
>     return resolvingType.visit(WTF::makeVisitor([](UniqueRef<AST::UnnamedType>& type) -> AST::UnnamedType* {
>         return &type;
>-    }, [](RefPtr<ResolvableTypeReference>& type) -> AST::UnnamedType* {
>+    }, [](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> AST::UnnamedType* {
>         // FIXME: If the type isn't committed, should we just commit() it now?
>-        return type->resolvableType().maybeResolvedType();
>+        AST::UnnamedType* result = nullptr;
>+        bool ok = true;
>+        resolvableTypeReference->forEachType([&] (AST::ResolvableType& type) {
>+            if (!type.maybeResolvedType())
>+                ok = false;
>+            if (!ok)
>+                return;
>+            if (!result) {
>+                result = type.maybeResolvedType();
>+                return;
>+            }
>+            if (!matches(*result, *type.maybeResolvedType()))
>+                ok = false;
>+        });
>+        return ok ? result : nullptr;
>     }));
> }
> 
>@@ -1009,7 +1126,7 @@ void Checker::finishVisiting(AST::Proper
>     auto baseInfo = recurseAndGetInfo(propertyAccessExpression.base());
>     if (!baseInfo)
>         return;
>-    auto baseUnnamedType = commit(baseInfo->resolvingType);
>+    auto baseUnnamedType = commit(propertyAccessExpression, baseInfo->resolvingType);
>     if (!baseUnnamedType)
>         return;
> 
>@@ -1201,8 +1318,8 @@ bool Checker::isBoolType(ResolvingType& 
> {
>     return resolvingType.visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& left) -> bool {
>         return matches(left, m_intrinsics.boolType());
>-    }, [&](RefPtr<ResolvableTypeReference>& left) -> bool {
>-        return static_cast<bool>(matchAndCommit(m_intrinsics.boolType(), left->resolvableType()));
>+    }, [&](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> bool {
>+        return static_cast<bool>(matchAndCommit(resolvableTypeReference, static_cast<AST::NamedType&>(m_intrinsics.boolType())));
>     }));
> }
> 
>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.cpp
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.cpp	(revision 247086)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.cpp	(working copy)
>@@ -208,7 +208,11 @@ ALWAYS_INLINE bool inferTypesForCallImpl
>         auto success = argumentTypes[i].get().visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>& unnamedType) -> bool {
>             return matches(*possibleFunction.parameters()[i]->type(), unnamedType);
>         }, [&](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> bool {
>-            return resolvableTypeReference->resolvableType().canResolve(possibleFunction.parameters()[i]->type()->unifyNode());
>+            bool ok = true;
>+            resolvableTypeReference->forEachType([&] (AST::ResolvableType& type) {
>+                ok &= type.canResolve(possibleFunction.parameters()[i]->type()->unifyNode());
>+            });
>+            return ok;
>         }));
>         if (!success)
>             return false;
>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp	(revision 247086)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp	(working copy)
>@@ -364,8 +364,7 @@ auto Parser::parseConstantExpression() -
>         auto value = floatLiteralToFloat(type->stringView);
>         if (!value)
>             return Unexpected<Error>(value.error());
>-        return {{ AST::FloatLiteral(WTFMove(*type), *value) }};
>-    }
>+        return {{ AST::FloatLiteral(WTFMove(*type), *value) }}; }
>     case Lexer::Token::Type::Null:
>         return { AST::NullLiteral(WTFMove(*type)) };
>     case Lexer::Token::Type::True:
>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp	(revision 247086)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp	(working copy)
>@@ -60,7 +60,7 @@ namespace WHLSL {
> 
> static constexpr bool dumpASTBeforeEachPass = false;
> static constexpr bool dumpASTAfterParsing = false;
>-static constexpr bool dumpASTAtEnd = false;
>+static constexpr bool dumpASTAtEnd = true;
> static constexpr bool alwaysDumpPassFailures = false;
> static constexpr bool dumpPassFailure = dumpASTBeforeEachPass || dumpASTAfterParsing || dumpASTAtEnd || alwaysDumpPassFailures;
> 
>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLResolveOverloadImpl.cpp
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLResolveOverloadImpl.cpp	(revision 247086)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLResolveOverloadImpl.cpp	(working copy)
>@@ -44,7 +44,12 @@ static unsigned conversionCost(AST::Func
>         conversionCost += argumentTypes[i].get().visit(WTF::makeVisitor([&](UniqueRef<AST::UnnamedType>&) -> unsigned {
>             return 0;
>         }, [&](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> unsigned {
>-            return resolvableTypeReference->resolvableType().conversionCost(*candidate.parameters()[i]->type());
>+            unsigned cost = 0;
>+            resolvableTypeReference->forEachType([&] (AST::ResolvableType& type) {
>+                // OOPS. We should find out what is specified here!
>+                cost = std::max(cost, type.conversionCost(*candidate.parameters()[i]->type()));
>+            });
>+            return cost;
>         }));
>     }
>     // The return type can never be a literal type, so its conversion cost is always 0.
>Index: Source/WebCore/Modules/webgpu/WHLSL/WHLSLResolvingType.h
>===================================================================
>--- Source/WebCore/Modules/webgpu/WHLSL/WHLSLResolvingType.h	(revision 247086)
>+++ Source/WebCore/Modules/webgpu/WHLSL/WHLSLResolvingType.h	(working copy)
>@@ -59,15 +59,50 @@ public:
>     {
>     }
> 
>+    ResolvableTypeReference(RefPtr<ResolvableTypeReference> left, RefPtr<ResolvableTypeReference> right)
>+        : m_left(WTFMove(left))
>+        , m_right(WTFMove(right))
>+    {
>+    }
>+
>     ResolvableTypeReference(const ResolvableTypeReference&) = delete;
>     ResolvableTypeReference(ResolvableTypeReference&&) = delete;
>     ResolvableTypeReference& operator=(const ResolvableTypeReference&) = delete;
>     ResolvableTypeReference& operator=(ResolvableTypeReference&&) = delete;
> 
>-    AST::ResolvableType& resolvableType() { return *m_resolvableType; }
>+    template <typename Function>
>+    void forEachType(Function function)
>+    {
>+        if (m_resolvableType)
>+            function(*m_resolvableType);
>+
>+        if (m_left) {
>+            ASSERT(m_right);
>+            m_left->forEachType(function);
>+            m_right->forEachType(function);
>+        } else
>+            ASSERT(!m_right);
>+    }
>+
>+    void setParent(ResolvableTypeReference& parent)
>+    {
>+        ASSERT(!m_parent);
>+        m_parent = &parent;
>+    }
>+
>+    ResolvableTypeReference& root()
>+    {
>+        ResolvableTypeReference* result = this;
>+        while (result->m_parent)
>+            result = result->m_parent;
>+        return *result;
>+    }
> 
> private:
>-    AST::ResolvableType* m_resolvableType;
>+    AST::ResolvableType* m_resolvableType { nullptr };
>+    RefPtr<ResolvableTypeReference> m_left;
>+    RefPtr<ResolvableTypeReference> m_right;
>+    ResolvableTypeReference* m_parent { nullptr };
> };
> 
> // This is a thin wrapper around a Variant.
>@@ -91,17 +126,10 @@ public:
>     }
> 
>     ResolvingType(const ResolvingType&) = delete;
>-    ResolvingType(ResolvingType&& other)
>-        : m_inner(WTFMove(other.m_inner))
>-    {
>-    }
>+    ResolvingType(ResolvingType&&) = default;
> 
>     ResolvingType& operator=(const ResolvingType&) = delete;
>-    ResolvingType& operator=(ResolvingType&& other)
>-    {
>-        m_inner = WTFMove(other.m_inner);
>-        return *this;
>-    }
>+    ResolvingType& operator=(ResolvingType&& other) = default;
> 
>     AST::UnnamedType* getUnnamedType()
>     {
>Index: LayoutTests/webgpu/whlsl-nested-resolvable-types.html
>===================================================================
>--- LayoutTests/webgpu/whlsl-nested-resolvable-types.html	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-nested-resolvable-types.html	(working copy)
>@@ -0,0 +1,123 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+<script src="../resources/js-test-pre.js"></script>
>+<script src="js/webgpu-functions.js"></script>
>+</head>
>+<body>
>+<script>
>+const shaderSource = `
>+void foo(uint x)
>+{
>+}
>+
>+void bar(int x)
>+{
>+}
>+
>+void baz(float x)
>+{
>+}
>+
>+[numthreads(1, 1, 1)]
>+compute void computeShader(device int[] buffer : register(u0), float3 threadID : SV_DispatchThreadID) {
>+    bool b = true;
>+
>+    //(b ? (b ? 10 : 20) : (b ? 10 : (b ? 40 : 20)));
>+    //(b ? (b ? 10 : 20) : (b ? 10 : (b ? 40 : 20)));
>+    //(b ? (b ? 10 : 20) : (b ? 10 : (b ? 40 : 20)));
>+    //(b ? (b ? 10 : 20) : (b ? 10 : (b ? 40 : 20)));
>+    //(b ? (b ? 10 : 20) : (b ? 10 : (b ? 40 : 20)));
>+    //(b ? (b ? 10 : 20) : (b ? 10 : (b ? 40 : 20)));
>+    //(b ? (b ? 10 : 20) : (b ? 10 : (b ? 40 : 20)));
>+    //(b ? (b ? 10 : 20) : (b ? 10 : (b ? 40 : 20)));
>+    //(b ? (b ? 10 : 20) : (b ? 10 : (b ? 40 : 20)));
>+    //(b ? (b ? 10 : (b ? 20 : 30)) : (b ? 10 : (b ? 40 : 20)));
>+
>+    (b ? 10.0 : 20);
>+    (b ? 20 : 10.0);
>+
>+    uint x = b ? 10 : 20;
>+    uint x2 = b ? 2147483647 : 24;
>+    foo(b ? 10 : 20);
>+    foo(b ? (b ? 2147483647 : 10) : 20);
>+    foo(b ? (b ? 2147483647 : 10) : (b ? 20 : (b ? 45 : 55)));
>+
>+    bar(b ? (b ? 2147483647 : 10) : (b ? 20 : (b ? 45 : 55)));
>+    baz(b ? (b ? 2147483647 : 10) : (b ? 20 : (b ? 45 : 55)));
>+
>+    baz(b ? (b ? 2147483647 : 10.5) : (b ? 20 : (b ? 45 : 55)));
>+
>+    //int x2 = b ? 10.0 : 20;
>+    //int x2 = 10.0;
>+
>+    //float y = b ? 10.5 : 20;
>+    //float y2 = b ? (b ? 20 : 10.5) : 20;
>+    //thread int* ptr = b ? null : null;
>+    
>+    buffer[0] = 1;
>+}
>+`;
>+async function start(device) {
>+    const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
>+    const computeStage = {module: shaderModule, entryPoint: "computeShader"};
>+
>+    const bindGroupLayoutDescriptor = {bindings: [{binding: 0, visibility: 7, type: "storage-buffer"}]};
>+    const bindGroupLayout = device.createBindGroupLayout(bindGroupLayoutDescriptor);
>+    const pipelineLayoutDescriptor = {bindGroupLayouts: [bindGroupLayout]};
>+    const pipelineLayout = device.createPipelineLayout(pipelineLayoutDescriptor);
>+
>+    const computePipelineDescriptor = {computeStage, layout: pipelineLayout};
>+    const computePipeline = device.createComputePipeline(computePipelineDescriptor);
>+
>+    const size = Int32Array.BYTES_PER_ELEMENT * 1;
>+
>+    const bufferDescriptor = {size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.TRANSFER_SRC};
>+    const buffer = device.createBuffer(bufferDescriptor);
>+    const bufferArrayBuffer = await buffer.mapWriteAsync();
>+    const bufferFloat32Array = new Int32Array(bufferArrayBuffer);
>+    bufferFloat32Array[0] = 0;
>+    buffer.unmap();
>+
>+    const resultsBufferDescriptor = {size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.TRANSFER_DST | GPUBufferUsage.MAP_READ};
>+    const resultsBuffer = device.createBuffer(resultsBufferDescriptor);
>+
>+    const bufferBinding = {buffer: resultsBuffer, size};
>+    const bindGroupBinding = {binding: 0, resource: bufferBinding};
>+    const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
>+    const bindGroup = device.createBindGroup(bindGroupDescriptor);
>+
>+    const commandEncoder = device.createCommandEncoder(); // {}
>+    commandEncoder.copyBufferToBuffer(buffer, 0, resultsBuffer, 0, size);
>+    const computePassEncoder = commandEncoder.beginComputePass();
>+    computePassEncoder.setPipeline(computePipeline);
>+    computePassEncoder.setBindGroup(0, bindGroup);
>+    computePassEncoder.dispatch(1, 1, 1);
>+    computePassEncoder.endPass();
>+    const commandBuffer = commandEncoder.finish();
>+    device.getQueue().submit([commandBuffer]);
>+
>+    const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
>+    let resultsInt32Array = new Int32Array(resultsArrayBuffer);
>+    if (resultsInt32Array[0] === 1)
>+        testPassed("");
>+    else
>+        testFailed("");
>+    resultsBuffer.unmap();
>+}
>+window.jsTestIsAsync = true;
>+getBasicDevice().then(function(device) {
>+    start(device).then(function() {
>+        finishJSTest();
>+    }, function() {
>+        testFailed("");
>+        finishJSTest();
>+    });
>+}, function() {
>+    testPassed("");
>+    finishJSTest();
>+});
>+</script>
>+<script src="../resources/js-test-post.js"></script>
>+</body>
>+</html>

Actions: View | Formatted Diff | Diff

Attachments on bug 199289: 373448 | 373449 | 373457 | 373458