Attachment 370912 Details for Bug 198163 – WIP

[patch] WIP

bug-198163-20190529195830.patch (text/plain), 22.61 KB, created by Myles C. Maxfield on 2019-05-29 19:58:30 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Myles C. Maxfield

Created: 2019-05-29 19:58:30 PDT

Size: 22.61 KB

patch

obsolete

>Subversion Revision: 245863
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index b9caceeec616f0f7836228566437c414f6c6a518..ffa6dd4d97406a535180a03dfcfc46447bc234ee 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-29  Ryan Haddad  <ryanhaddad@apple.com>
> 
>         Unreviewed, rolling out r245857.
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLIndexExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLIndexExpression.h
>index aa197b5af43bd60388c7185ad146e8ec03d32e8c..7adf1e8e2289c1d68b302e2bb983cee574d8b8d2 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLIndexExpression.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLIndexExpression.h
>@@ -68,6 +68,7 @@ public:
>     }
> 
>     Expression& indexExpression() { return m_index; }
>+    UniqueRef<Expression> takeIndex() { return WTFMove(m_index); }
> 
> private:
>     UniqueRef<Expression> m_index;
>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 75578a49b29a894ddf70211d6e5e1ce9775ae7ac..45cad0eb6ffcd031d0f307f796177f934d4ba027 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)
>@@ -1362,7 +1381,7 @@ void Checker::visit(AST::CommaExpression& commaExpression)
>     if (error())
>         return;
>     auto lastInfo = getInfo(commaExpression.list().last());
>-    forwardType(commaExpression, lastInfo->resolvingType, lastInfo->typeAnnotation);
>+    forwardType(commaExpression, lastInfo->resolvingType);
> }
> 
> void Checker::visit(AST::TernaryExpression& ternaryExpression)
>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&);
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp
>index fa069cabce204d379ef6568e7d926073792f85e7..f28e437ca5299e02915d802b3bf18282ccc4a7b3 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp
>@@ -51,10 +51,11 @@ public:
> private:
>     void visit(AST::FunctionDefinition&) override;
>     void visit(AST::DotExpression&) override;
>+    void visit(AST::IndexExpression&) override;
>     void visit(AST::AssignmentExpression&) override;
>     void visit(AST::ReadModifyWriteExpression&) override;
> 
>-    bool simplifyRightValue(AST::DotExpression&);
>+    bool simplifyRightValue(AST::PropertyAccessExpression&, Optional<UniqueRef<AST::Expression>>&& additionalArgument);
>     bool simplifyAbstractLeftValue(AST::AssignmentExpression&, AST::DotExpression&, UniqueRef<AST::Expression>&& right);
>     void simplifyLeftValue(AST::Expression&);
> 
>@@ -64,7 +65,15 @@ private:
> void PropertyResolver::visit(AST::DotExpression& dotExpression)
> {
>     // Unless we're inside an AssignmentExpression or a ReadModifyWriteExpression, we're a right value.
>-    if (!simplifyRightValue(dotExpression))
>+    if (!simplifyRightValue(dotExpression, WTF::nullopt))
>+        setError();
>+}
>+
>+void PropertyResolver::visit(AST::IndexExpression& indexExpression)
>+{
>+    checkErrorAndVisit(indexExpression.indexExpression());
>+    // Unless we're inside an AssignmentExpression or a ReadModifyWriteExpression, we're a right value.
>+    if (!simplifyRightValue(indexExpression, indexExpression.takeIndex()))
>         setError();
> }
> 
>@@ -581,27 +590,29 @@ void PropertyResolver::visit(AST::ReadModifyWriteExpression& readModifyWriteExpr
>     m_variableDeclarations.append(WTFMove(newVariableDeclaration));
> }
> 
>-bool PropertyResolver::simplifyRightValue(AST::DotExpression& dotExpression)
>+bool PropertyResolver::simplifyRightValue(AST::PropertyAccessExpression& propertyAccessExpression, Optional<UniqueRef<AST::Expression>>&& additionalArgument)
> {
>-    Lexer::Token origin = dotExpression.origin();
>+    Lexer::Token origin = propertyAccessExpression.origin();
> 
>-    checkErrorAndVisit(dotExpression.base());
>+    checkErrorAndVisit(propertyAccessExpression.base());
> 
>-    if (auto* anderFunction = dotExpression.anderFunction()) {
>-        auto& base = dotExpression.base();
>+    if (auto* anderFunction = propertyAccessExpression.anderFunction()) {
>+        auto& base = propertyAccessExpression.base();
>         if (auto leftAddressSpace = base.typeAnnotation().leftAddressSpace()) {
>-            auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), dotExpression.takeBase());
>+            auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), propertyAccessExpression.takeBase());
>             makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), *leftAddressSpace, base.resolvedType().clone()));
>             makePointerExpression->setTypeAnnotation(AST::RightValue());
> 
>             Vector<UniqueRef<AST::Expression>> arguments;
>             arguments.append(WTFMove(makePointerExpression));
>+            if (additionalArgument)
>+                arguments.append(WTFMove(*additionalArgument));
>             auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(anderFunction->name()), WTFMove(arguments));
>             callExpression->setType(anderFunction->type().clone());
>             callExpression->setTypeAnnotation(AST::RightValue());
>             callExpression->setFunction(*anderFunction);
> 
>-            auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(dotExpression, WTFMove(origin), WTFMove(callExpression));
>+            auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(propertyAccessExpression, WTFMove(origin), WTFMove(callExpression));
>             dereferenceExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
>             dereferenceExpression->setTypeAnnotation(AST::LeftValue { downcast<AST::PointerType>(anderFunction->type()).addressSpace() });
>             return true;
>@@ -609,7 +620,7 @@ bool PropertyResolver::simplifyRightValue(AST::DotExpression& dotExpression)
> 
>         // We have an ander, but no left value to call it on. Let's save the value into a temporary variable to create a left value.
>         // This is effectively inlining the functions the spec says are generated.
>-        if (!dotExpression.threadAnderFunction())
>+        if (!propertyAccessExpression.threadAnderFunction())
>             return false;
> 
>         auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), base.resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt);
>@@ -618,7 +629,7 @@ bool PropertyResolver::simplifyRightValue(AST::DotExpression& dotExpression)
>         variableReference1->setType(base.resolvedType().clone());
>         variableReference1->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
> 
>-        auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(origin), WTFMove(variableReference1), dotExpression.takeBase());
>+        auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(origin), WTFMove(variableReference1), propertyAccessExpression.takeBase());
>         assignmentExpression->setType(base.resolvedType().clone());
>         assignmentExpression->setTypeAnnotation(AST::RightValue());
> 
>@@ -632,6 +643,8 @@ bool PropertyResolver::simplifyRightValue(AST::DotExpression& dotExpression)
> 
>         Vector<UniqueRef<AST::Expression>> arguments;
>         arguments.append(WTFMove(makePointerExpression));
>+        if (additionalArgument)
>+            arguments.append(WTFMove(*additionalArgument));
>         auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(anderFunction->name()), WTFMove(arguments));
>         callExpression->setType(anderFunction->type().clone());
>         callExpression->setTypeAnnotation(AST::RightValue());
>@@ -644,7 +657,7 @@ bool PropertyResolver::simplifyRightValue(AST::DotExpression& dotExpression)
>         Vector<UniqueRef<AST::Expression>> expressions;
>         expressions.append(WTFMove(assignmentExpression));
>         expressions.append(WTFMove(dereferenceExpression));
>-        auto* commaExpression = AST::replaceWith<AST::CommaExpression>(dotExpression, WTFMove(origin), WTFMove(expressions));
>+        auto* commaExpression = AST::replaceWith<AST::CommaExpression>(propertyAccessExpression, WTFMove(origin), WTFMove(expressions));
>         commaExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
>         commaExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
> 
>@@ -652,11 +665,13 @@ bool PropertyResolver::simplifyRightValue(AST::DotExpression& dotExpression)
>         return true;
>     }
> 
>-    ASSERT(dotExpression.getterFunction());
>-    auto& getterFunction = *dotExpression.getterFunction();
>+    ASSERT(propertyAccessExpression.getterFunction());
>+    auto& getterFunction = *propertyAccessExpression.getterFunction();
>     Vector<UniqueRef<AST::Expression>> arguments;
>-    arguments.append(dotExpression.takeBase());
>-    auto* callExpression = AST::replaceWith<AST::CallExpression>(dotExpression, WTFMove(origin), String(getterFunction.name()), WTFMove(arguments));
>+    arguments.append(propertyAccessExpression.takeBase());
>+    if (additionalArgument)
>+        arguments.append(WTFMove(*additionalArgument));
>+    auto* callExpression = AST::replaceWith<AST::CallExpression>(propertyAccessExpression, WTFMove(origin), String(getterFunction.name()), WTFMove(arguments));
>     callExpression->setFunction(getterFunction);
>     callExpression->setType(getterFunction.type().clone());
>     callExpression->setTypeAnnotation(AST::RightValue());
>@@ -664,45 +679,59 @@ bool PropertyResolver::simplifyRightValue(AST::DotExpression& dotExpression)
> }
> 
> class LeftValueSimplifier : public Visitor {
>-public:
>+private:
>     void visit(AST::DotExpression&) override;
>+    void visit(AST::IndexExpression&) override;
>     void visit(AST::DereferenceExpression&) override;
> 
>-private:
>+    void finishVisiting(AST::PropertyAccessExpression&, Optional<UniqueRef<AST::Expression>>&& additionalArgument);
> };
> 
>-void LeftValueSimplifier::visit(AST::DotExpression& dotExpression)
>+void LeftValueSimplifier::finishVisiting(AST::PropertyAccessExpression& propertyAccessExpression, Optional<UniqueRef<AST::Expression>>&& additionalArgument)
> {
>-    Visitor::visit(dotExpression);
>-    ASSERT(dotExpression.base().typeAnnotation().leftAddressSpace());
>-    ASSERT(dotExpression.anderFunction());
>-
>-    Lexer::Token origin = dotExpression.origin();
>-    auto* anderFunction = dotExpression.anderFunction();
>-    auto& base = dotExpression.base();
>-    auto leftAddressSpace = *dotExpression.base().typeAnnotation().leftAddressSpace();
>-    auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), dotExpression.takeBase());
>+    ASSERT(propertyAccessExpression.base().typeAnnotation().leftAddressSpace());
>+    ASSERT(propertyAccessExpression.anderFunction());
>+
>+    Lexer::Token origin = propertyAccessExpression.origin();
>+    auto* anderFunction = propertyAccessExpression.anderFunction();
>+    auto& base = propertyAccessExpression.base();
>+    auto leftAddressSpace = *propertyAccessExpression.base().typeAnnotation().leftAddressSpace();
>+    auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), propertyAccessExpression.takeBase());
>     makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), leftAddressSpace, base.resolvedType().clone()));
>     makePointerExpression->setTypeAnnotation(AST::RightValue());
> 
>     Vector<UniqueRef<AST::Expression>> arguments;
>     arguments.append(WTFMove(makePointerExpression));
>+    if (additionalArgument)
>+        arguments.append(WTFMove(*additionalArgument));
>     auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(anderFunction->name()), WTFMove(arguments));
>     callExpression->setType(anderFunction->type().clone());
>     callExpression->setTypeAnnotation(AST::RightValue());
>     callExpression->setFunction(*anderFunction);
> 
>-    auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(dotExpression, WTFMove(origin), WTFMove(callExpression));
>+    auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(propertyAccessExpression, WTFMove(origin), WTFMove(callExpression));
>     dereferenceExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
>     dereferenceExpression->setTypeAnnotation(AST::LeftValue { downcast<AST::PointerType>(anderFunction->type()).addressSpace() });
> }
> 
>+void LeftValueSimplifier::visit(AST::DotExpression& dotExpression)
>+{
>+    Visitor::visit(dotExpression);
>+    finishVisiting(dotExpression, WTF::nullopt);
>+}
>+
>+void LeftValueSimplifier::visit(AST::IndexExpression& indexExpression)
>+{
>+    Visitor::visit(indexExpression);
>+    PropertyResolver().Visitor::visit(indexExpression);
>+    finishVisiting(indexExpression, indexExpression.takeIndex());
>+}
>+
> void LeftValueSimplifier::visit(AST::DereferenceExpression& dereferenceExpression)
> {
>     // Dereference expressions are the only expressions where the children might be more-right than we are.
>     // For example, a dereference expression may be a left value but its child may be a call expression which is a right value.
>     // LeftValueSimplifier doesn't handle right values, so we instead need to use PropertyResolver.
>-    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198170 What about function call arguments?
>     PropertyResolver().Visitor::visit(dereferenceExpression);
> }
>

Actions: View | Formatted Diff | Diff

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