Attachment 370874 Details for Bug 198163 – WIP

[patch] WIP

bug-198163-20190529121520.patch (text/plain), 9.94 KB, created by Myles C. Maxfield on 2019-05-29 12:15:21 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Myles C. Maxfield

Created: 2019-05-29 12:15:21 PDT

Size: 9.94 KB

patch

obsolete

>Subversion Revision: 245839
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 1986a95b324a470ce0db00c2d6e07368f68b2274..6ac75006bf30a0762e71c3cc99e805aa9000dee7 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,18 @@
>+2019-05-29  Myles C. Maxfield  <mmaxfield@apple.com>
>+
>+        [WHLSL] Implement arrays and array references
>+        https://bugs.webkit.org/show_bug.cgi?id=198163
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        No new tests (OOPS!).
>+
>+        * Modules/webgpu/WHLSL/AST/WHLSLReferenceType.h:
>+        * Modules/webgpu/WHLSL/WHLSLChecker.cpp:
>+        (WebCore::WHLSL::Checker::finishVisiting):
>+        (WebCore::WHLSL::Checker::visit):
>+        * Modules/webgpu/WHLSL/WHLSLInferTypes.h:
>+
> 2019-05-28  Wenson Hsieh  <wenson_hsieh@apple.com>
> 
>         [iOS] Respect NSItemProvider's registered types when dropping files that are loaded in-place
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReferenceType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReferenceType.h
>index 8811ac9ad427dd02e7f141b06432bc5033869653..1e6ce164c6cbdb1938c92b594e0060e091295944 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReferenceType.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReferenceType.h
>@@ -53,7 +53,7 @@ public:
>     ReferenceType(const ReferenceType&) = delete;
>     ReferenceType(ReferenceType&&) = default;
> 
>-    bool isReferenceType() const override { return false; }
>+    bool isReferenceType() const override { return true; }
> 
>     AddressSpace addressSpace() const { return m_addressSpace; }
>     const UnnamedType& elementType() const { return m_elementType; }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>index 1dedcf0efd9f3a6c492246f19b699aebbbc51e79..ccd089c8658c4319764d3cf4c6f5e3abf239659e 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>@@ -491,6 +491,8 @@ private:
>     void visit(AST::TernaryExpression&) override;
>     void visit(AST::CallExpression&) override;
> 
>+    void finishVisiting(AST::PropertyAccessExpression&, ResolvingType* additionalArgumentType = nullptr);
>+
>     HashMap<AST::Expression*, ResolvingType> m_typeMap;
>     HashMap<AST::Expression*, AST::TypeAnnotation> m_typeAnnotations;
>     HashSet<String> m_vertexEntryPoints;
>@@ -966,9 +968,9 @@ void Checker::visit(AST::MakeArrayReferenceExpression& makeArrayReferenceExpress
>     assignType(makeArrayReferenceExpression, makeUniqueRef<AST::ArrayReferenceType>(Lexer::Token(makeArrayReferenceExpression.origin()), *leftAddressSpace, leftValueType->clone()));
> }
> 
>-void Checker::visit(AST::DotExpression& dotExpression)
>+void Checker::finishVisiting(AST::PropertyAccessExpression& propertyAccessExpression, ResolvingType* additionalArgumentType)
> {
>-    auto baseInfo = recurseAndGetInfo(dotExpression.base());
>+    auto baseInfo = recurseAndGetInfo(propertyAccessExpression.base());
>     if (!baseInfo)
>         return;
>     auto baseUnnamedType = commit(baseInfo->resolvingType);
>@@ -979,7 +981,9 @@ void Checker::visit(AST::DotExpression& dotExpression)
>     AST::UnnamedType* getterReturnType = nullptr;
>     {
>         Vector<std::reference_wrapper<ResolvingType>> getterArgumentTypes { baseInfo->resolvingType };
>-        getterFunction = resolveFunctionOverloadImpl(dotExpression.possibleGetterOverloads(), getterArgumentTypes, nullptr);
>+        if (additionalArgumentType)
>+            getterArgumentTypes.append(*additionalArgumentType);
>+        getterFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleGetterOverloads(), getterArgumentTypes, nullptr);
>         if (getterFunction)
>             getterReturnType = &getterFunction->type();
>     }
>@@ -987,9 +991,11 @@ void Checker::visit(AST::DotExpression& dotExpression)
>     AST::FunctionDeclaration* anderFunction = nullptr;
>     AST::UnnamedType* anderReturnType = nullptr;
>     if (auto leftAddressSpace = baseInfo->typeAnnotation.leftAddressSpace()) {
>-        auto argumentType = makeUniqueRef<AST::PointerType>(Lexer::Token(dotExpression.origin()), *leftAddressSpace, baseUnnamedType->get().clone());
>-        Vector<std::reference_wrapper<ResolvingType>> anderArgumentTypes { baseInfo->resolvingType };
>-        anderFunction = resolveFunctionOverloadImpl(dotExpression.possibleAnderOverloads(), anderArgumentTypes, nullptr);
>+        ResolvingType argumentType = { makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), *leftAddressSpace, baseUnnamedType->get().clone()) };
>+        Vector<std::reference_wrapper<ResolvingType>> anderArgumentTypes { argumentType };
>+        if (additionalArgumentType)
>+            anderArgumentTypes.append(*additionalArgumentType);
>+        anderFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleAnderOverloads(), anderArgumentTypes, nullptr);
>         if (anderFunction)
>             anderReturnType = &downcast<AST::PointerType>(anderFunction->type()).elementType(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198164 Enforce the return of anders will always be a pointer
>     }
>@@ -997,9 +1003,11 @@ void Checker::visit(AST::DotExpression& dotExpression)
>     AST::FunctionDeclaration* threadAnderFunction = nullptr;
>     AST::UnnamedType* threadAnderReturnType = nullptr;
>     {
>-        auto argumentType = makeUniqueRef<AST::PointerType>(Lexer::Token(dotExpression.origin()), AST::AddressSpace::Thread, baseUnnamedType->get().clone());
>-        Vector<std::reference_wrapper<ResolvingType>> threadAnderArgumentTypes { baseInfo->resolvingType };
>-        threadAnderFunction = resolveFunctionOverloadImpl(dotExpression.possibleAnderOverloads(), threadAnderArgumentTypes, nullptr);
>+        ResolvingType argumentType = { makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), AST::AddressSpace::Thread, baseUnnamedType->get().clone()) };
>+        Vector<std::reference_wrapper<ResolvingType>> threadAnderArgumentTypes { argumentType };
>+        if (additionalArgumentType)
>+            threadAnderArgumentTypes.append(*additionalArgumentType);
>+        threadAnderFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleAnderOverloads(), threadAnderArgumentTypes, nullptr);
>         if (threadAnderFunction)
>             threadAnderReturnType = &downcast<AST::PointerType>(threadAnderFunction->type()).elementType(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198164 Enforce the return of anders will always be a pointer
>     }
>@@ -1023,8 +1031,11 @@ void Checker::visit(AST::DotExpression& dotExpression)
>     AST::UnnamedType* setterReturnType = nullptr;
>     {
>         ResolvingType fieldResolvingType(fieldType->clone());
>-        Vector<std::reference_wrapper<ResolvingType>> setterArgumentTypes { baseInfo->resolvingType, fieldResolvingType };
>-        setterFunction = resolveFunctionOverloadImpl(dotExpression.possibleSetterOverloads(), setterArgumentTypes, nullptr);
>+        Vector<std::reference_wrapper<ResolvingType>> setterArgumentTypes { baseInfo->resolvingType };
>+        if (additionalArgumentType)
>+            setterArgumentTypes.append(*additionalArgumentType);
>+        setterArgumentTypes.append(fieldResolvingType);
>+        setterFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleSetterOverloads(), setterArgumentTypes, nullptr);
>         if (setterFunction)
>             setterReturnType = &setterFunction->type();
>     }
>@@ -1034,10 +1045,10 @@ void Checker::visit(AST::DotExpression& dotExpression)
>         return;
>     }
> 
>-    dotExpression.setGetterFunction(getterFunction);
>-    dotExpression.setAnderFunction(anderFunction);
>-    dotExpression.setThreadAnderFunction(threadAnderFunction);
>-    dotExpression.setSetterFunction(setterFunction);
>+    propertyAccessExpression.setGetterFunction(getterFunction);
>+    propertyAccessExpression.setAnderFunction(anderFunction);
>+    propertyAccessExpression.setThreadAnderFunction(threadAnderFunction);
>+    propertyAccessExpression.setSetterFunction(setterFunction);
> 
>     AST::TypeAnnotation typeAnnotation = AST::RightValue();
>     if (auto leftAddressSpace = baseInfo->typeAnnotation.leftAddressSpace()) {
>@@ -1047,12 +1058,20 @@ void Checker::visit(AST::DotExpression& dotExpression)
>             typeAnnotation = AST::AbstractLeftValue();
>     } else if (!baseInfo->typeAnnotation.isRightValue() && (setterFunction || anderFunction))
>         typeAnnotation = AST::AbstractLeftValue();
>-    assignType(dotExpression, fieldType->clone(), WTFMove(typeAnnotation));
>+    assignType(propertyAccessExpression, fieldType->clone(), WTFMove(typeAnnotation));
>+}
>+
>+void Checker::visit(AST::DotExpression& dotExpression)
>+{
>+    finishVisiting(dotExpression);
> }
> 
>-void Checker::visit(AST::IndexExpression&)
>+void Checker::visit(AST::IndexExpression& indexExpression)
> {
>-    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198163 Implement this.
>+    auto baseInfo = recurseAndGetInfo(indexExpression.indexExpression());
>+    if (!baseInfo)
>+        return;
>+    finishVisiting(indexExpression, &baseInfo->resolvingType);
> }
> 
> void Checker::visit(AST::VariableReference& variableReference)
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.h
>index 173d3014497d2a3742e80670f80bc96ff0f79c4d..19fb1ffcf814414cd6a227dea8943055028eb0ac 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.h
>@@ -47,7 +47,6 @@ class UnnamedType;
> bool matches(const AST::UnnamedType&, const AST::UnnamedType&);
> bool matches(const AST::NamedType&, const AST::NamedType&);
> bool matches(const AST::UnnamedType&, const AST::NamedType&);
>-// FIXME: Is anyone actually using the return type here?
> Optional<UniqueRef<AST::UnnamedType>> matchAndCommit(AST::UnnamedType&, AST::ResolvableType&);
> Optional<UniqueRef<AST::UnnamedType>> matchAndCommit(AST::NamedType&, AST::ResolvableType&);
> Optional<UniqueRef<AST::UnnamedType>> matchAndCommit(AST::ResolvableType&, AST::ResolvableType&);

Actions: View | Formatted Diff | Diff

Attachments on bug 198163: 370830 | 370874 | 370912 | 371158 | 371243 | 371373 | 371374 | 371375 | 371471 | 371475 | 371555 | 371900