Changeset 246225 in webkit


Ignore:
Timestamp:
Jun 7, 2019 5:03:58 PM (5 years ago)
Author:
Truitt Savell
Message:

Unreviewed, rolling out r246138.

Broke internal builds

Reverted changeset:

"[WHLSL] Educate the property resolver about IndexExpressions"
​https://bugs.webkit.org/show_bug.cgi?id=198399
​https://trac.webkit.org/changeset/246138

Location:
trunk
Files:
1 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r246223 r246225  
     12019-06-07  Truitt Savell  <tsavell@apple.com>
     2
     3        Unreviewed, rolling out r246138.
     4
     5        Broke internal builds
     6
     7        Reverted changeset:
     8
     9        "[WHLSL] Educate the property resolver about IndexExpressions"
     10        https://bugs.webkit.org/show_bug.cgi?id=198399
     11        https://trac.webkit.org/changeset/246138
     12
    1132019-06-07  Nikita Vasilyev  <nvasilyev@apple.com>
    214

  • trunk/Source/WebCore/ChangeLog

    r246218 r246225  
     12019-06-07  Truitt Savell  <tsavell@apple.com>
     2
     3        Unreviewed, rolling out r246138.
     4
     5        Broke internal builds
     6
     7        Reverted changeset:
     8
     9        "[WHLSL] Educate the property resolver about IndexExpressions"
     10        https://bugs.webkit.org/show_bug.cgi?id=198399
     11        https://trac.webkit.org/changeset/246138
     12
    1132019-06-07  Justin Fan  <justin_fan@apple.com>
    214

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAddressSpace.h

    r246138 r246225  
    4444};
    4545
    46 ALWAYS_INLINE String toString(AddressSpace addressSpace)
     46static ALWAYS_INLINE String toString(AddressSpace addressSpace)
    4747{
    4848    switch (addressSpace) {

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLEntryPointType.h

    r246138 r246225  
    4242};
    4343
    44 ALWAYS_INLINE String toString(EntryPointType type)
     44static ALWAYS_INLINE String toString(EntryPointType type)
    4545{
    4646    switch (type) {

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLIndexExpression.h

    r246138 r246225  
    6060    String setterFunctionName() const override
    6161    {
    62         return "operator[]="_str;
     62        return "operator&[]"_str;
    6363    }
    6464
    6565    String anderFunctionName() const override
    6666    {
    67         return "operator&[]"_str;
     67        return "operator[]="_str;
    6868    }
    6969
    7070    Expression& indexExpression() { return m_index; }
    71     UniqueRef<Expression> takeIndex() { return WTFMove(m_index); }
    7271
    7372private:

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReferenceType.h

    r246138 r246225  
    5454    ReferenceType(ReferenceType&&) = default;
    5555
    56     bool isReferenceType() const override { return true; }
     56    bool isReferenceType() const override { return false; }
    5757
    5858    AddressSpace addressSpace() const { return m_addressSpace; }

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp

    r246138 r246225  
    6464}
    6565
     66static String convertAddressSpace(AST::AddressSpace addressSpace)
     67{
     68    switch (addressSpace) {
     69    case AST::AddressSpace::Constant:
     70        return "constant"_str;
     71    case AST::AddressSpace::Device:
     72        return "device"_str;
     73    case AST::AddressSpace::Threadgroup:
     74        return "threadgroup"_str;
     75    default:
     76        ASSERT(addressSpace == AST::AddressSpace::Thread);
     77        return "thread"_str;
     78    }
     79}
     80
    6681static String atomicName(String input)
    6782{
    … …  
    361376            auto fourthArgumentAddressSpace = fourthArgumentPointer.addressSpace();
    362377            auto fourthArgumentPointee = typeNamer.mangledNameForType(fourthArgumentPointer.elementType());
    363             stringBuilder.append(makeString("void ", outputFunctionName, '(', toString(firstArgumentAddressSpace), ' ', firstArgumentPointee, "* object, ", secondArgument, " compare, ", thirdArgument, " desired, ", toString(fourthArgumentAddressSpace), ' ', fourthArgumentPointee, "* out) {\n"));
     378            stringBuilder.append(makeString("void ", outputFunctionName, '(', convertAddressSpace(firstArgumentAddressSpace), ' ', firstArgumentPointee, "* object, ", secondArgument, " compare, ", thirdArgument, " desired, ", convertAddressSpace(fourthArgumentAddressSpace), ' ', fourthArgumentPointee, "* out) {\n"));
    364379            stringBuilder.append("    atomic_compare_exchange_weak_explicit(object, &compare, desired, memory_order_relaxed);\n");
    365380            stringBuilder.append("    *out = compare;\n");
    … …  
    379394        auto thirdArgumentPointee = typeNamer.mangledNameForType(thirdArgumentPointer.elementType());
    380395        auto name = atomicName(nativeFunctionDeclaration.name().substring("Interlocked"_str.length()));
    381         stringBuilder.append(makeString("void ", outputFunctionName, '(', toString(firstArgumentAddressSpace), ' ', firstArgumentPointee, "* object, ", secondArgument, " operand, ", toString(thirdArgumentAddressSpace), ' ', thirdArgumentPointee, "* out) {\n"));
     396        stringBuilder.append(makeString("void ", outputFunctionName, '(', convertAddressSpace(firstArgumentAddressSpace), ' ', firstArgumentPointee, "* object, ", secondArgument, " operand, ", convertAddressSpace(thirdArgumentAddressSpace), ' ', thirdArgumentPointee, "* out) {\n"));
    382397        stringBuilder.append(makeString("    *out = atomic_fetch_", name, "_explicit(object, operand, memory_order_relaxed);\n"));
    383398        stringBuilder.append("}\n");

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp

    r246138 r246225  
    3737#include "WHLSLDoWhileLoop.h"
    3838#include "WHLSLDotExpression.h"
    39 #include "WHLSLEntryPointType.h"
    4039#include "WHLSLForLoop.h"
    4140#include "WHLSLGatherEntryPointItems.h"
    … …  
    356355        Vector<std::reference_wrapper<ResolvingType>> argumentTypeReferences;
    357356        for (size_t i = 0; i < numExpectedParameters - 1; ++i)
    358             argumentTypes.append((*functionDefinition.parameters()[i]->type())->clone());
     357            argumentTypes.append((*functionDefinition.parameters()[0]->type())->clone());
    359358        for (auto& argumentType : argumentTypes)
    360359            argumentTypeReferences.append(argumentType);
    … …  
    493492    void visit(AST::CallExpression&) override;
    494493
    495     void finishVisiting(AST::PropertyAccessExpression&, ResolvingType* additionalArgumentType = nullptr);
    496 
    497494    HashMap<AST::Expression*, ResolvingType> m_typeMap;
    498495    HashMap<AST::Expression*, AST::TypeAnnotation> m_typeAnnotations;
    … …  
    970967}
    971968
    972 void Checker::finishVisiting(AST::PropertyAccessExpression& propertyAccessExpression, ResolvingType* additionalArgumentType)
    973 {
    974     auto baseInfo = recurseAndGetInfo(propertyAccessExpression.base());
     969void Checker::visit(AST::DotExpression& dotExpression)
     970{
     971    auto baseInfo = recurseAndGetInfo(dotExpression.base());
    975972    if (!baseInfo)
    976973        return;
    … …  
    983980    {
    984981        Vector<std::reference_wrapper<ResolvingType>> getterArgumentTypes { baseInfo->resolvingType };
    985         if (additionalArgumentType)
    986             getterArgumentTypes.append(*additionalArgumentType);
    987         if ((getterFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleGetterOverloads(), getterArgumentTypes, nullptr)))
     982        getterFunction = resolveFunctionOverloadImpl(dotExpression.possibleGetterOverloads(), getterArgumentTypes, nullptr);
     983        if (getterFunction)
    988984            getterReturnType = &getterFunction->type();
    989985    }
    … …  
    991987    AST::FunctionDeclaration* anderFunction = nullptr;
    992988    AST::UnnamedType* anderReturnType = nullptr;
    993     auto leftAddressSpace = baseInfo->typeAnnotation.leftAddressSpace();
    994     if (leftAddressSpace) {
    995         ResolvingType argumentType = { makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), *leftAddressSpace, baseUnnamedType->get().clone()) };
    996         Vector<std::reference_wrapper<ResolvingType>> anderArgumentTypes { argumentType };
    997         if (additionalArgumentType)
    998             anderArgumentTypes.append(*additionalArgumentType);
    999         if ((anderFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleAnderOverloads(), anderArgumentTypes, nullptr)))
     989    if (auto leftAddressSpace = baseInfo->typeAnnotation.leftAddressSpace()) {
     990        auto argumentType = makeUniqueRef<AST::PointerType>(Lexer::Token(dotExpression.origin()), *leftAddressSpace, baseUnnamedType->get().clone());
     991        Vector<std::reference_wrapper<ResolvingType>> anderArgumentTypes { baseInfo->resolvingType };
     992        anderFunction = resolveFunctionOverloadImpl(dotExpression.possibleAnderOverloads(), anderArgumentTypes, nullptr);
     993        if (anderFunction)
    1000994            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
    1001995    }
    … …  
    1004998    AST::UnnamedType* threadAnderReturnType = nullptr;
    1005999    {
    1006         ResolvingType argumentType = { makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), AST::AddressSpace::Thread, baseUnnamedType->get().clone()) };
    1007         Vector<std::reference_wrapper<ResolvingType>> threadAnderArgumentTypes { argumentType };
    1008         if (additionalArgumentType)
    1009             threadAnderArgumentTypes.append(*additionalArgumentType);
    1010         if ((threadAnderFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleAnderOverloads(), threadAnderArgumentTypes, nullptr)))
     1000        auto argumentType = makeUniqueRef<AST::PointerType>(Lexer::Token(dotExpression.origin()), AST::AddressSpace::Thread, baseUnnamedType->get().clone());
     1001        Vector<std::reference_wrapper<ResolvingType>> threadAnderArgumentTypes { baseInfo->resolvingType };
     1002        threadAnderFunction = resolveFunctionOverloadImpl(dotExpression.possibleAnderOverloads(), threadAnderArgumentTypes, nullptr);
     1003        if (threadAnderFunction)
    10111004            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
    10121005    }
    10131006
    1014     if (leftAddressSpace && !anderFunction && !getterFunction) {
    1015         setError();
    1016         return;
    1017     }
    1018 
    1019     if (!leftAddressSpace && !threadAnderFunction && !getterFunction) {
    1020         setError();
    1021         return;
    1022     }
    1023 
    1024     if (threadAnderFunction && getterFunction) {
    1025         setError();
    1026         return;
    1027     }
    1028 
     1007    if (!getterFunction && !anderFunction) {
     1008        setError();
     1009        return;
     1010    }
     1011    if (getterFunction && anderFunction) {
     1012        setError();
     1013        return;
     1014    }
    10291015    if (anderFunction && threadAnderFunction && !matches(*anderReturnType, *threadAnderReturnType)) {
    10301016        setError();
    … …  
    10321018    }
    10331019
    1034     if (getterFunction && anderFunction && !matches(*getterReturnType, *anderReturnType)) {
    1035         setError();
    1036         return;
    1037     }
    1038 
    1039     if (getterFunction && threadAnderFunction && !matches(*getterReturnType, *threadAnderReturnType)) {
    1040         setError();
    1041         return;
    1042     }
    1043 
    1044     AST::UnnamedType* fieldType = getterReturnType ? getterReturnType : anderReturnType ? anderReturnType : threadAnderReturnType;
     1020    AST::UnnamedType* fieldType = getterReturnType ? getterReturnType : anderReturnType;
    10451021
    10461022    AST::FunctionDeclaration* setterFunction = nullptr;
    … …  
    10481024    {
    10491025        ResolvingType fieldResolvingType(fieldType->clone());
    1050         Vector<std::reference_wrapper<ResolvingType>> setterArgumentTypes { baseInfo->resolvingType };
    1051         if (additionalArgumentType)
    1052             setterArgumentTypes.append(*additionalArgumentType);
    1053         setterArgumentTypes.append(fieldResolvingType);
    1054         setterFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleSetterOverloads(), setterArgumentTypes, nullptr);
     1026        Vector<std::reference_wrapper<ResolvingType>> setterArgumentTypes { baseInfo->resolvingType, fieldResolvingType };
     1027        setterFunction = resolveFunctionOverloadImpl(dotExpression.possibleSetterOverloads(), setterArgumentTypes, nullptr);
    10551028        if (setterFunction)
    10561029            setterReturnType = &setterFunction->type();
    10571030    }
    10581031
    1059     if (setterFunction && !getterFunction) {
    1060         setError();
    1061         return;
    1062     }
    1063 
    1064     propertyAccessExpression.setGetterFunction(getterFunction);
    1065     propertyAccessExpression.setAnderFunction(anderFunction);
    1066     propertyAccessExpression.setThreadAnderFunction(threadAnderFunction);
    1067     propertyAccessExpression.setSetterFunction(setterFunction);
     1032    if (setterFunction && anderFunction) {
     1033        setError();
     1034        return;
     1035    }
     1036
     1037    dotExpression.setGetterFunction(getterFunction);
     1038    dotExpression.setAnderFunction(anderFunction);
     1039    dotExpression.setThreadAnderFunction(threadAnderFunction);
     1040    dotExpression.setSetterFunction(setterFunction);
    10681041
    10691042    AST::TypeAnnotation typeAnnotation = AST::RightValue();
    … …  
    10731046        else if (setterFunction)
    10741047            typeAnnotation = AST::AbstractLeftValue();
    1075     } else if (!baseInfo->typeAnnotation.isRightValue() && (setterFunction || threadAnderFunction))
     1048    } else if (!baseInfo->typeAnnotation.isRightValue() && (setterFunction || anderFunction))
    10761049        typeAnnotation = AST::AbstractLeftValue();
    1077     assignType(propertyAccessExpression, fieldType->clone(), WTFMove(typeAnnotation));
    1078 }
    1079 
    1080 void Checker::visit(AST::DotExpression& dotExpression)
    1081 {
    1082     finishVisiting(dotExpression);
    1083 }
    1084 
    1085 void Checker::visit(AST::IndexExpression& indexExpression)
    1086 {
    1087     auto baseInfo = recurseAndGetInfo(indexExpression.indexExpression());
    1088     if (!baseInfo)
    1089         return;
    1090     finishVisiting(indexExpression, &baseInfo->resolvingType);
     1050    assignType(dotExpression, fieldType->clone(), WTFMove(typeAnnotation));
     1051}
     1052
     1053void Checker::visit(AST::IndexExpression&)
     1054{
     1055    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198163 Implement this.
    10911056}
    10921057
    … …  
    13981363        return;
    13991364    auto lastInfo = getInfo(commaExpression.list().last());
    1400     forwardType(commaExpression, lastInfo->resolvingType);
     1365    forwardType(commaExpression, lastInfo->resolvingType, lastInfo->typeAnnotation);
    14011366}
    14021367

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLInferTypes.h

    r246138 r246225  
    4848bool matches(const AST::NamedType&, const AST::NamedType&);
    4949bool matches(const AST::UnnamedType&, const AST::NamedType&);
     50// FIXME: Is anyone actually using the return type here?
    5051Optional<UniqueRef<AST::UnnamedType>> matchAndCommit(AST::UnnamedType&, AST::ResolvableType&);
    5152Optional<UniqueRef<AST::UnnamedType>> matchAndCommit(AST::NamedType&, AST::ResolvableType&);

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp

    r246138 r246225  
    5252    void visit(AST::FunctionDefinition&) override;
    5353    void visit(AST::DotExpression&) override;
    54     void visit(AST::IndexExpression&) override;
    5554    void visit(AST::AssignmentExpression&) override;
    5655    void visit(AST::ReadModifyWriteExpression&) override;
    5756
    58     bool simplifyRightValue(AST::PropertyAccessExpression&);
     57    bool simplifyRightValue(AST::DotExpression&);
    5958    bool simplifyAbstractLeftValue(AST::AssignmentExpression&, AST::DotExpression&, UniqueRef<AST::Expression>&& right);
    6059    void simplifyLeftValue(AST::Expression&);
    … …  
    7069}
    7170
    72 void PropertyResolver::visit(AST::IndexExpression& indexExpression)
    73 {
    74     checkErrorAndVisit(indexExpression.indexExpression());
    75     // Unless we're inside an AssignmentExpression or a ReadModifyWriteExpression, we're a right value.
    76     if (!simplifyRightValue(indexExpression))
    77         setError();
    78 }
    79 
    8071void PropertyResolver::visit(AST::FunctionDefinition& functionDefinition)
    8172{
    … …  
    8576}
    8677
    87 static Optional<UniqueRef<AST::Expression>> setterCall(AST::PropertyAccessExpression& propertyAccessExpression, AST::FunctionDeclaration* relevantAnder, UniqueRef<AST::Expression>&& newValue, const std::function<UniqueRef<AST::Expression>()>& leftValueFactory, const std::function<UniqueRef<AST::Expression>()>& pointerToLeftValueFactory, AST::VariableDeclaration* indexVariable)
    88 {
    89     auto maybeAddIndexArgument = [&](Vector<UniqueRef<AST::Expression>>& arguments) {
    90         if (!indexVariable)
    91             return;
    92         auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(*indexVariable));
    93         ASSERT(indexVariable->type());
    94         variableReference->setType(indexVariable->type()->clone());
    95         variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
    96         arguments.append(WTFMove(variableReference));
    97     };
    98 
    99     if (relevantAnder) {
     78static Optional<UniqueRef<AST::Expression>> setterCall(AST::DotExpression& dotExpression, UniqueRef<AST::Expression>&& newValue, const std::function<UniqueRef<AST::Expression>()>& leftValueFactory, const std::function<UniqueRef<AST::Expression>()>& pointerToLeftValueFactory)
     79{
     80    if (dotExpression.anderFunction()) {
    10081        // *operator&.foo(&v) = newValue
     82        if (!dotExpression.threadAnderFunction())
     83            return WTF::nullopt;
     84       
    10185        Vector<UniqueRef<AST::Expression>> arguments;
    10286        arguments.append(pointerToLeftValueFactory());
    103         maybeAddIndexArgument(arguments);
    104 
    105         auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(propertyAccessExpression.origin()), String(relevantAnder->name()), WTFMove(arguments));
    106         callExpression->setType(relevantAnder->type().clone());
     87        auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(dotExpression.origin()), String(dotExpression.threadAnderFunction()->name()), WTFMove(arguments));
     88        callExpression->setType(dotExpression.threadAnderFunction()->type().clone());
    10789        callExpression->setTypeAnnotation(AST::RightValue());
    108         callExpression->setFunction(*relevantAnder);
    109 
    110         auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(callExpression));
    111         dereferenceExpression->setType(downcast<AST::PointerType>(relevantAnder->type()).elementType().clone());
     90        callExpression->setFunction(*dotExpression.threadAnderFunction());
     91
     92        auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(dotExpression.origin()), WTFMove(callExpression));
     93        dereferenceExpression->setType(downcast<AST::PointerType>(dotExpression.threadAnderFunction()->type()).elementType().clone());
    11294        dereferenceExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
    11395
    114         auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(dereferenceExpression), WTFMove(newValue));
    115         assignmentExpression->setType(downcast<AST::PointerType>(relevantAnder->type()).elementType().clone());
     96        auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(dotExpression.origin()), WTFMove(dereferenceExpression), WTFMove(newValue));
     97        assignmentExpression->setType(downcast<AST::PointerType>(dotExpression.threadAnderFunction()->type()).elementType().clone());
    11698        assignmentExpression->setTypeAnnotation(AST::RightValue());
    11799
    … …  
    120102
    121103    // v = operator.foo=(v, newValue)
    122     ASSERT(propertyAccessExpression.setterFunction());
     104    ASSERT(dotExpression.setterFunction());
    123105
    124106    Vector<UniqueRef<AST::Expression>> arguments;
    125107    arguments.append(leftValueFactory());
    126     maybeAddIndexArgument(arguments);
    127108    arguments.append(WTFMove(newValue));
    128 
    129     auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(propertyAccessExpression.origin()), String(propertyAccessExpression.setterFunction()->name()), WTFMove(arguments));
    130     callExpression->setType(propertyAccessExpression.setterFunction()->type().clone());
     109    auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(dotExpression.origin()), String(dotExpression.setterFunction()->name()), WTFMove(arguments));
     110    callExpression->setType(dotExpression.setterFunction()->type().clone());
    131111    callExpression->setTypeAnnotation(AST::RightValue());
    132     callExpression->setFunction(*propertyAccessExpression.setterFunction());
    133 
    134     auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(propertyAccessExpression.origin()), leftValueFactory(), WTFMove(callExpression));
    135     assignmentExpression->setType(propertyAccessExpression.setterFunction()->type().clone());
     112    callExpression->setFunction(*dotExpression.setterFunction());
     113
     114    auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(dotExpression.origin()), leftValueFactory(), WTFMove(callExpression));
     115    assignmentExpression->setType(dotExpression.setterFunction()->type().clone());
    136116    assignmentExpression->setTypeAnnotation(AST::RightValue());
    137117
    … …  
    139119}
    140120
    141 static Optional<UniqueRef<AST::Expression>> getterCall(AST::PropertyAccessExpression& propertyAccessExpression, AST::FunctionDeclaration* relevantAnder, const std::function<UniqueRef<AST::Expression>()>& leftValueFactory, const std::function<UniqueRef<AST::Expression>()>& pointerToLeftValueFactory, AST::VariableDeclaration* indexVariable)
    142 {
    143     auto maybeAddIndexArgument = [&](Vector<UniqueRef<AST::Expression>>& arguments) {
    144         if (!indexVariable)
    145             return;
    146         auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(*indexVariable));
    147         ASSERT(indexVariable->type());
    148         variableReference->setType(indexVariable->type()->clone());
    149         variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
    150         arguments.append(WTFMove(variableReference));
    151     };
    152 
    153     if (relevantAnder) {
     121static Optional<UniqueRef<AST::Expression>> getterCall(AST::DotExpression& dotExpression, const std::function<UniqueRef<AST::Expression>()>& leftValueFactory, const std::function<UniqueRef<AST::Expression>()>& pointerToLeftValueFactory)
     122{
     123    if (dotExpression.anderFunction()) {
    154124        // *operator&.foo(&v)
     125        if (!dotExpression.threadAnderFunction())
     126            return WTF::nullopt;
     127       
    155128        Vector<UniqueRef<AST::Expression>> arguments;
    156129        arguments.append(pointerToLeftValueFactory());
    157         maybeAddIndexArgument(arguments);
    158 
    159         auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(propertyAccessExpression.origin()), String(relevantAnder->name()), WTFMove(arguments));
    160         callExpression->setType(relevantAnder->type().clone());
     130        auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(dotExpression.origin()), String(dotExpression.threadAnderFunction()->name()), WTFMove(arguments));
     131        callExpression->setType(dotExpression.threadAnderFunction()->type().clone());
    161132        callExpression->setTypeAnnotation(AST::RightValue());
    162         callExpression->setFunction(*relevantAnder);
    163 
    164         auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(callExpression));
    165         dereferenceExpression->setType(downcast<AST::PointerType>(relevantAnder->type()).elementType().clone());
     133        callExpression->setFunction(*dotExpression.threadAnderFunction());
     134
     135        auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(dotExpression.origin()), WTFMove(callExpression));
     136        dereferenceExpression->setType(downcast<AST::PointerType>(dotExpression.threadAnderFunction()->type()).elementType().clone());
    166137        dereferenceExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
    167138
    … …  
    170141
    171142    // operator.foo(v)
    172     ASSERT(propertyAccessExpression.getterFunction());
     143    ASSERT(dotExpression.getterFunction());
    173144   
    174145    Vector<UniqueRef<AST::Expression>> arguments;
    175146    arguments.append(leftValueFactory());
    176     maybeAddIndexArgument(arguments);
    177 
    178     auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(propertyAccessExpression.origin()), String(propertyAccessExpression.getterFunction()->name()), WTFMove(arguments));
    179     callExpression->setType(propertyAccessExpression.getterFunction()->type().clone());
     147    auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(dotExpression.origin()), String(dotExpression.getterFunction()->name()), WTFMove(arguments));
     148    callExpression->setType(dotExpression.getterFunction()->type().clone());
    180149    callExpression->setTypeAnnotation(AST::RightValue());
    181     callExpression->setFunction(*propertyAccessExpression.getterFunction());
     150    callExpression->setFunction(*dotExpression.getterFunction());
    182151
    183152    return UniqueRef<AST::Expression>(WTFMove(callExpression));
    … …  
    193162    UniqueRef<AST::Expression> result;
    194163};
    195 static Optional<ModifyResult> modify(AST::PropertyAccessExpression& propertyAccessExpression, std::function<Optional<ModificationResult>(Optional<UniqueRef<AST::Expression>>&&)> modification)
     164static Optional<ModifyResult> modify(AST::DotExpression& dotExpression, std::function<Optional<ModificationResult>(Optional<UniqueRef<AST::Expression>>&&)> modification)
    196165{
    197166    // Consider a.b.c.d++;
    … …  
    213182    // q = operator.c=(q, r);
    214183    //
    215     // Step 5:
     184    // Step 4:
    216185    // *p = operator.b=(*p, q);
    217186
    … …  
    220189
    221190    // Find the ".b" ".c" and ".d" expressions. They end up in the order [".d", ".c", ".b"].
    222     Vector<std::reference_wrapper<AST::PropertyAccessExpression>> chain;
    223     AST::PropertyAccessExpression* iterator = &propertyAccessExpression;
     191    Vector<std::reference_wrapper<AST::DotExpression>> chain;
     192    AST::DotExpression* iterator = &dotExpression;
    224193    while (true) {
    225194        chain.append(*iterator);
    … …  
    227196            break;
    228197        ASSERT(!iterator->base().typeAnnotation().isRightValue());
    229         ASSERT(is<AST::PropertyAccessExpression>(iterator->base()));
    230         iterator = &downcast<AST::PropertyAccessExpression>(iterator->base());
     198        ASSERT(is<AST::DotExpression>(iterator->base())); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198163 Make this work with index expressions
     199        iterator = &downcast<AST::DotExpression>(iterator->base());
    231200    }
    232201    auto leftExpression = iterator->takeBase();
    … …  
    240209    intermediateVariables.reserveInitialCapacity(chain.size() - 1);
    241210    for (size_t i = 1; i < chain.size(); ++i) {
    242         auto& propertyAccessExpression = static_cast<AST::PropertyAccessExpression&>(chain[i]);
    243         intermediateVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(propertyAccessExpression.origin()), AST::Qualifiers(), propertyAccessExpression.resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt));
    244     }
    245 
    246     // Consider a[foo()][b] = c;
    247     // Naively, This would get expanded to:
    248     //
    249     // temp = operator[](a, foo());
    250     // temp = operator[]=(temp, b, c);
    251     // a = operator[]=(a, foo(), temp);
    252     //
    253     // However, if we did this, we would have to run foo() twice, which would be incorrect.
    254     // Instead, we need to save foo() and b into more temporary variables.
    255     // These temporary variables are parallel to "chain" above, with nullopt referring to a DotExpression (which doesn't have an index value to save to a variable).
    256     //
    257     // Instead, this gets expanded to:
    258     //
    259     // p = &a;
    260     // temp = foo();
    261     // q = operator[](*p, temp);
    262     // temp2 = b;
    263     // q = operator[]=(q, temp2, c);
    264     // *p = operator[]=(*p, temp, q);
    265 
    266     Vector<Optional<UniqueRef<AST::VariableDeclaration>>> indexVariables;
    267     indexVariables.reserveInitialCapacity(chain.size());
    268     for (AST::PropertyAccessExpression& propertyAccessExpression : chain) {
    269         if (!is<AST::IndexExpression>(propertyAccessExpression)) {
    270             indexVariables.append(WTF::nullopt);
    271             continue;
    272         }
    273         auto& indexExpression = downcast<AST::IndexExpression>(propertyAccessExpression);
    274         indexVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(propertyAccessExpression.origin()), AST::Qualifiers(), indexExpression.indexExpression().resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt));
     211        auto& dotExpression = static_cast<AST::DotExpression&>(chain[i]);
     212        intermediateVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(dotExpression.origin()), AST::Qualifiers(), dotExpression.resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt));
    275213    }
    276214
    … …  
    311249        variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
    312250
    313         auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference));
     251        auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(dotExpression.origin()), WTFMove(variableReference));
    314252        ASSERT(pointerVariable->type());
    315253        dereferenceExpression->setType(downcast<AST::PointerType>(*pointerVariable->type()).elementType().clone());
    … …  
    324262            variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
    325263
    326             auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference));
     264            auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(dotExpression.origin()), WTFMove(variableReference));
    327265            ASSERT(previous->type());
    328             makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), AST::AddressSpace::Thread, previous->type()->clone()));
     266            makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(dotExpression.origin()), AST::AddressSpace::Thread, previous->type()->clone()));
    329267            makePointerExpression->setTypeAnnotation(AST::RightValue());
    330268            return makePointerExpression;
    … …  
    337275        return variableReference;
    338276    };
    339     auto appendIndexAssignment = [&](AST::PropertyAccessExpression& propertyAccessExpression, Optional<UniqueRef<AST::VariableDeclaration>>& indexVariable) {
    340         if (!indexVariable)
    341             return;
    342 
    343         auto& indexExpression = downcast<AST::IndexExpression>(propertyAccessExpression);
    344 
    345         auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(*indexVariable));
    346         ASSERT(indexVariable->get().type());
    347         variableReference->setType(indexVariable->get().type()->clone());
    348         variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
    349 
    350         auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference), indexExpression.takeIndex());
    351         assignmentExpression->setType(indexVariable->get().type()->clone());
    352         assignmentExpression->setTypeAnnotation(AST::RightValue());
    353 
    354         expressions.append(WTFMove(assignmentExpression));
    355     };
    356277    for (size_t i = chain.size(); --i; ) {
    357         AST::PropertyAccessExpression& propertyAccessExpression = chain[i];
     278        AST::DotExpression& dotExpression = chain[i];
    358279        AST::VariableDeclaration& variableDeclaration = intermediateVariables[i - 1];
    359         Optional<UniqueRef<AST::VariableDeclaration>>& indexVariable = indexVariables[i];
    360 
    361         appendIndexAssignment(propertyAccessExpression, indexVariable);
    362 
    363         AST::FunctionDeclaration* relevantAnder = i == chain.size() - 1 ? propertyAccessExpression.anderFunction() : propertyAccessExpression.threadAnderFunction();
    364         auto callExpression = getterCall(propertyAccessExpression, relevantAnder, previousLeftValue, pointerToPreviousLeftValue, indexVariable ? &*indexVariable : nullptr);
     280
     281        auto callExpression = getterCall(dotExpression, previousLeftValue, pointerToPreviousLeftValue);
    365282
    366283        if (!callExpression)
    … …  
    372289        variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
    373290
    374         auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference), WTFMove(*callExpression));
     291        auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(dotExpression.origin()), WTFMove(variableReference), WTFMove(*callExpression));
    375292        assignmentExpression->setType(variableDeclaration.type()->clone());
    376293        assignmentExpression->setTypeAnnotation(AST::RightValue());
    … …  
    380297        previous = &variableDeclaration;
    381298    }
    382     appendIndexAssignment(chain[0], indexVariables[0]);
    383     AST::FunctionDeclaration* relevantAnder = chain.size() == 1 ? propertyAccessExpression.anderFunction() : propertyAccessExpression.threadAnderFunction();
    384     auto lastGetterCallExpression = getterCall(chain[0], relevantAnder, previousLeftValue, pointerToPreviousLeftValue, indexVariables[0] ? &*(indexVariables[0]) : nullptr);
     299    auto lastGetterCallExpression = getterCall(chain[0], previousLeftValue, pointerToPreviousLeftValue);
    385300
    386301    // Step 3:
    … …  
    395310    auto expressionType = rightValue->resolvedType().clone();
    396311    for (size_t i = 0; i < chain.size() - 1; ++i) {
    397         AST::PropertyAccessExpression& propertyAccessExpression = chain[i];
     312        AST::DotExpression& dotExpression = chain[i];
    398313        AST::VariableDeclaration& variableDeclaration = intermediateVariables[i];
    399         Optional<UniqueRef<AST::VariableDeclaration>>& indexVariable = indexVariables[i];
    400 
    401         auto assignmentExpression = setterCall(propertyAccessExpression, propertyAccessExpression.threadAnderFunction(), WTFMove(rightValue), [&]() -> UniqueRef<AST::Expression> {
     314
     315        auto assignmentExpression = setterCall(dotExpression, WTFMove(rightValue), [&]() -> UniqueRef<AST::Expression> {
    402316            auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
    403317            ASSERT(variableDeclaration.type());
    … …  
    411325            variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
    412326
    413             auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference));
     327            auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(dotExpression.origin()), WTFMove(variableReference));
    414328            ASSERT(variableDeclaration.type());
    415             makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), AST::AddressSpace::Thread, variableDeclaration.type()->clone()));
     329            makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(dotExpression.origin()), AST::AddressSpace::Thread, variableDeclaration.type()->clone()));
    416330            makePointerExpression->setTypeAnnotation(AST::RightValue());
    417331            return makePointerExpression;
    418         }, indexVariable ? &*indexVariable : nullptr);
     332        });
    419333
    420334        if (!assignmentExpression)
    … …  
    431345    // Step 5:
    432346    {
    433         AST::PropertyAccessExpression& propertyAccessExpression = chain[chain.size() - 1];
    434         auto assignmentExpression = setterCall(propertyAccessExpression, propertyAccessExpression.anderFunction(), WTFMove(rightValue), [&]() -> UniqueRef<AST::Expression> {
     347        auto assignmentExpression = setterCall(chain[chain.size() - 1], WTFMove(rightValue), [&]() -> UniqueRef<AST::Expression> {
    435348            auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(pointerVariable));
    436349            ASSERT(pointerVariable->type());
    … …  
    438351            variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
    439352
    440             auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference));
     353            auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(dotExpression.origin()), WTFMove(variableReference));
    441354            ASSERT(pointerVariable->type());
    442355            dereferenceExpression->setType(downcast<AST::PointerType>(*pointerVariable->type()).elementType().clone());
    … …  
    449362            variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
    450363            return variableReference;
    451         }, indexVariables[indexVariables.size() - 1] ? &*(indexVariables[indexVariables.size() - 1]) : nullptr);
     364        });
    452365
    453366        if (!assignmentExpression)
    … …  
    461374    for (auto& intermediateVariable : intermediateVariables)
    462375        variableDeclarations.append(WTFMove(intermediateVariable));
    463     for (auto& indexVariable : indexVariables) {
    464         if (indexVariable)
    465             variableDeclarations.append(WTFMove(*indexVariable));
    466     }
    467376
    468377    return {{ innerLeftExpression, WTFMove(expressions), WTFMove(variableDeclarations) }};
    … …  
    477386    }
    478387    ASSERT(!assignmentExpression.left().typeAnnotation().isRightValue());
    479     ASSERT(is<AST::PropertyAccessExpression>(assignmentExpression.left()));
     388    if (!is<AST::DotExpression>(assignmentExpression.left())) {
     389        setError(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198163 Make this work with index expressions.
     390        return;
     391    }
    480392
    481393    auto type = assignmentExpression.right().resolvedType().clone();
    … …  
    483395    checkErrorAndVisit(assignmentExpression.right());
    484396
    485     auto modifyResult = modify(downcast<AST::PropertyAccessExpression>(assignmentExpression.left()), [&](Optional<UniqueRef<AST::Expression>>&&) -> Optional<ModificationResult> {
     397    auto modifyResult = modify(downcast<AST::DotExpression>(assignmentExpression.left()), [&](Optional<UniqueRef<AST::Expression>>&&) -> Optional<ModificationResult> {
    486398        return {{ Vector<UniqueRef<AST::Expression>>(), assignmentExpression.takeRight() }};
    487399    });
    … …  
    513425        // *p = newValue;
    514426
    515         simplifyLeftValue(readModifyWriteExpression.leftValue());
    516 
    517427        auto baseType = readModifyWriteExpression.leftValue().resolvedType().clone();
    518428        auto pointerType = makeUniqueRef<AST::PointerType>(Lexer::Token(readModifyWriteExpression.leftValue().origin()), *readModifyWriteExpression.leftValue().typeAnnotation().leftAddressSpace(), baseType->clone());
    … …  
    611521
    612522    ASSERT(!readModifyWriteExpression.leftValue().typeAnnotation().isRightValue());
    613     if (!is<AST::PropertyAccessExpression>(readModifyWriteExpression.leftValue())) {
    614         setError();
     523    if (!is<AST::DotExpression>(readModifyWriteExpression.leftValue())) {
     524        setError(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198163 Make this work with index expressions.
    615525        return;
    616526    }
    617     auto modifyResult = modify(downcast<AST::PropertyAccessExpression>(readModifyWriteExpression.leftValue()), [&](Optional<UniqueRef<AST::Expression>>&& lastGetterCallExpression) -> Optional<ModificationResult> {
     527    auto modifyResult = modify(downcast<AST::DotExpression>(readModifyWriteExpression.leftValue()), [&](Optional<UniqueRef<AST::Expression>>&& lastGetterCallExpression) -> Optional<ModificationResult> {
    618528        Vector<UniqueRef<AST::Expression>> expressions;
    619529        if (!lastGetterCallExpression)
    … …  
    672582}
    673583
    674 bool PropertyResolver::simplifyRightValue(AST::PropertyAccessExpression& propertyAccessExpression)
    675 {
    676     Lexer::Token origin = propertyAccessExpression.origin();
    677 
    678     checkErrorAndVisit(propertyAccessExpression.base());
    679 
    680     auto& base = propertyAccessExpression.base();
    681     if (auto leftAddressSpace = base.typeAnnotation().leftAddressSpace()) {
    682         if (auto* anderFunction = propertyAccessExpression.anderFunction()) {
    683             auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), propertyAccessExpression.takeBase());
     584bool PropertyResolver::simplifyRightValue(AST::DotExpression& dotExpression)
     585{
     586    Lexer::Token origin = dotExpression.origin();
     587
     588    checkErrorAndVisit(dotExpression.base());
     589
     590    if (auto* anderFunction = dotExpression.anderFunction()) {
     591        auto& base = dotExpression.base();
     592        if (auto leftAddressSpace = base.typeAnnotation().leftAddressSpace()) {
     593            auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), dotExpression.takeBase());
    684594            makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), *leftAddressSpace, base.resolvedType().clone()));
    685595            makePointerExpression->setTypeAnnotation(AST::RightValue());
    … …  
    687597            Vector<UniqueRef<AST::Expression>> arguments;
    688598            arguments.append(WTFMove(makePointerExpression));
    689             if (is<AST::IndexExpression>(propertyAccessExpression))
    690                 arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
    691599            auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(anderFunction->name()), WTFMove(arguments));
    692600            callExpression->setType(anderFunction->type().clone());
    … …  
    694602            callExpression->setFunction(*anderFunction);
    695603
    696             auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(propertyAccessExpression, WTFMove(origin), WTFMove(callExpression));
     604            auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(dotExpression, WTFMove(origin), WTFMove(callExpression));
    697605            dereferenceExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
    698606            dereferenceExpression->setTypeAnnotation(AST::LeftValue { downcast<AST::PointerType>(anderFunction->type()).addressSpace() });
    699607            return true;
    700608        }
    701     }
    702 
    703     if (propertyAccessExpression.getterFunction()) {
    704         auto& getterFunction = *propertyAccessExpression.getterFunction();
     609
     610        // 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.
     611        // This is effectively inlining the functions the spec says are generated.
     612        if (!dotExpression.threadAnderFunction())
     613            return false;
     614
     615        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), base.resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt);
     616
     617        auto variableReference1 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
     618        variableReference1->setType(base.resolvedType().clone());
     619        variableReference1->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
     620
     621        auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(origin), WTFMove(variableReference1), dotExpression.takeBase());
     622        assignmentExpression->setType(base.resolvedType().clone());
     623        assignmentExpression->setTypeAnnotation(AST::RightValue());
     624
     625        auto variableReference2 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
     626        variableReference2->setType(base.resolvedType().clone());
     627        variableReference2->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
     628
     629        auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), WTFMove(variableReference2));
     630        makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), AST::AddressSpace::Thread, base.resolvedType().clone()));
     631        makePointerExpression->setTypeAnnotation(AST::RightValue());
     632
    705633        Vector<UniqueRef<AST::Expression>> arguments;
    706         arguments.append(propertyAccessExpression.takeBase());
    707         if (is<AST::IndexExpression>(propertyAccessExpression))
    708             arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
    709         auto* callExpression = AST::replaceWith<AST::CallExpression>(propertyAccessExpression, WTFMove(origin), String(getterFunction.name()), WTFMove(arguments));
    710         callExpression->setFunction(getterFunction);
    711         callExpression->setType(getterFunction.type().clone());
     634        arguments.append(WTFMove(makePointerExpression));
     635        auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(anderFunction->name()), WTFMove(arguments));
     636        callExpression->setType(anderFunction->type().clone());
    712637        callExpression->setTypeAnnotation(AST::RightValue());
     638        callExpression->setFunction(*anderFunction);
     639
     640        auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(WTFMove(origin), WTFMove(callExpression));
     641        dereferenceExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
     642        dereferenceExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
     643
     644        Vector<UniqueRef<AST::Expression>> expressions;
     645        expressions.append(WTFMove(assignmentExpression));
     646        expressions.append(WTFMove(dereferenceExpression));
     647        auto* commaExpression = AST::replaceWith<AST::CommaExpression>(dotExpression, WTFMove(origin), WTFMove(expressions));
     648        commaExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
     649        commaExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
     650
     651        m_variableDeclarations.append(WTFMove(variableDeclaration));
    713652        return true;
    714653    }
    715654
    716     // 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.
    717     // This is effectively inlining the functions the spec says are generated.
    718     ASSERT(propertyAccessExpression.threadAnderFunction());
    719     auto* threadAnderFunction = propertyAccessExpression.threadAnderFunction();
    720 
    721     auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), base.resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt);
    722 
    723     auto variableReference1 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
    724     variableReference1->setType(base.resolvedType().clone());
    725     variableReference1->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
    726 
    727     auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(origin), WTFMove(variableReference1), propertyAccessExpression.takeBase());
    728     assignmentExpression->setType(base.resolvedType().clone());
    729     assignmentExpression->setTypeAnnotation(AST::RightValue());
    730 
    731     auto variableReference2 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
    732     variableReference2->setType(base.resolvedType().clone());
    733     variableReference2->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
    734 
    735     auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), WTFMove(variableReference2));
    736     makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), AST::AddressSpace::Thread, base.resolvedType().clone()));
     655    ASSERT(dotExpression.getterFunction());
     656    auto& getterFunction = *dotExpression.getterFunction();
     657    Vector<UniqueRef<AST::Expression>> arguments;
     658    arguments.append(dotExpression.takeBase());
     659    auto* callExpression = AST::replaceWith<AST::CallExpression>(dotExpression, WTFMove(origin), String(getterFunction.name()), WTFMove(arguments));
     660    callExpression->setFunction(getterFunction);
     661    callExpression->setType(getterFunction.type().clone());
     662    callExpression->setTypeAnnotation(AST::RightValue());
     663    return true;
     664}
     665
     666class LeftValueSimplifier : public Visitor {
     667public:
     668    void visit(AST::DotExpression&) override;
     669    void visit(AST::DereferenceExpression&) override;
     670
     671private:
     672};
     673
     674void LeftValueSimplifier::visit(AST::DotExpression& dotExpression)
     675{
     676    Visitor::visit(dotExpression);
     677    ASSERT(dotExpression.base().typeAnnotation().leftAddressSpace());
     678    ASSERT(dotExpression.anderFunction());
     679
     680    Lexer::Token origin = dotExpression.origin();
     681    auto* anderFunction = dotExpression.anderFunction();
     682    auto& base = dotExpression.base();
     683    auto leftAddressSpace = *dotExpression.base().typeAnnotation().leftAddressSpace();
     684    auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), dotExpression.takeBase());
     685    makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), leftAddressSpace, base.resolvedType().clone()));
    737686    makePointerExpression->setTypeAnnotation(AST::RightValue());
    738687
    739688    Vector<UniqueRef<AST::Expression>> arguments;
    740689    arguments.append(WTFMove(makePointerExpression));
    741     if (is<AST::IndexExpression>(propertyAccessExpression))
    742         arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
    743     auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(threadAnderFunction->name()), WTFMove(arguments));
    744     callExpression->setType(threadAnderFunction->type().clone());
    745     callExpression->setTypeAnnotation(AST::RightValue());
    746     callExpression->setFunction(*threadAnderFunction);
    747 
    748     auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(WTFMove(origin), WTFMove(callExpression));
    749     dereferenceExpression->setType(downcast<AST::PointerType>(threadAnderFunction->type()).elementType().clone());
    750     dereferenceExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
    751 
    752     Vector<UniqueRef<AST::Expression>> expressions;
    753     expressions.append(WTFMove(assignmentExpression));
    754     expressions.append(WTFMove(dereferenceExpression));
    755     auto* commaExpression = AST::replaceWith<AST::CommaExpression>(propertyAccessExpression, WTFMove(origin), WTFMove(expressions));
    756     commaExpression->setType(downcast<AST::PointerType>(threadAnderFunction->type()).elementType().clone());
    757     commaExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
    758 
    759     m_variableDeclarations.append(WTFMove(variableDeclaration));
    760     return true;
    761 
    762 }
    763 
    764 class LeftValueSimplifier : public Visitor {
    765 private:
    766     void visit(AST::DotExpression&) override;
    767     void visit(AST::IndexExpression&) override;
    768     void visit(AST::DereferenceExpression&) override;
    769 
    770     void finishVisiting(AST::PropertyAccessExpression&);
    771 };
    772 
    773 void LeftValueSimplifier::finishVisiting(AST::PropertyAccessExpression& propertyAccessExpression)
    774 {
    775     ASSERT(propertyAccessExpression.base().typeAnnotation().leftAddressSpace());
    776     ASSERT(propertyAccessExpression.anderFunction());
    777 
    778     Lexer::Token origin = propertyAccessExpression.origin();
    779     auto* anderFunction = propertyAccessExpression.anderFunction();
    780     auto& base = propertyAccessExpression.base();
    781     auto leftAddressSpace = *propertyAccessExpression.base().typeAnnotation().leftAddressSpace();
    782     auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), propertyAccessExpression.takeBase());
    783     makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), leftAddressSpace, base.resolvedType().clone()));
    784     makePointerExpression->setTypeAnnotation(AST::RightValue());
    785 
    786     Vector<UniqueRef<AST::Expression>> arguments;
    787     arguments.append(WTFMove(makePointerExpression));
    788     if (is<AST::IndexExpression>(propertyAccessExpression))
    789         arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
    790690    auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(anderFunction->name()), WTFMove(arguments));
    791691    callExpression->setType(anderFunction->type().clone());
    … …  
    793693    callExpression->setFunction(*anderFunction);
    794694
    795     auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(propertyAccessExpression, WTFMove(origin), WTFMove(callExpression));
     695    auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(dotExpression, WTFMove(origin), WTFMove(callExpression));
    796696    dereferenceExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
    797697    dereferenceExpression->setTypeAnnotation(AST::LeftValue { downcast<AST::PointerType>(anderFunction->type()).addressSpace() });
    798 }
    799 
    800 void LeftValueSimplifier::visit(AST::DotExpression& dotExpression)
    801 {
    802     Visitor::visit(dotExpression);
    803     finishVisiting(dotExpression);
    804 }
    805 
    806 void LeftValueSimplifier::visit(AST::IndexExpression& indexExpression)
    807 {
    808     Visitor::visit(indexExpression);
    809     PropertyResolver().Visitor::visit(indexExpression.indexExpression());
    810     finishVisiting(indexExpression);
    811698}
    812699
    … …  
    816703    // For example, a dereference expression may be a left value but its child may be a call expression which is a right value.
    817704    // LeftValueSimplifier doesn't handle right values, so we instead need to use PropertyResolver.
     705    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198170 What about function call arguments?
    818706    PropertyResolver().Visitor::visit(dereferenceExpression);
    819707}

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt

    r246138 r246225  
    376376native typedef TextureDepthCube<float>;
    377377
    378 native operator uchar(ushort);
    379 native operator uchar(uint);
    380 native operator uchar(char);
    381 native operator uchar(short);
    382 native operator uchar(int);
    383 native operator uchar(half);
    384 native operator uchar(float);
    385 native operator ushort(uchar);
    386 native operator ushort(uint);
    387 native operator ushort(char);
    388 native operator ushort(short);
    389 native operator ushort(int);
    390 native operator ushort(half);
    391 native operator ushort(float);
    392 native operator uint(uchar);
    393 native operator uint(ushort);
    394 native operator uint(char);
    395 native operator uint(short);
    396 native operator uint(int);
    397 native operator uint(half);
    398 native operator uint(float);
    399 native operator char(uchar);
    400 native operator char(ushort);
    401 native operator char(uint);
    402 native operator char(short);
    403 native operator char(int);
    404 native operator char(half);
    405 native operator char(float);
    406 native operator short(uchar);
    407 native operator short(ushort);
    408 native operator short(uint);
    409 native operator short(char);
    410 native operator short(int);
    411 native operator short(half);
    412 native operator short(float);
    413 native operator int(uchar);
    414 native operator int(ushort);
    415 native operator int(uint);
    416 native operator int(char);
    417 native operator int(short);
    418 native operator int(half);
    419 native operator int(float);
    420 native operator half(uchar);
    421 native operator half(ushort);
    422 native operator half(uint);
    423 native operator half(char);
    424 native operator half(short);
    425 native operator half(int);
    426 native operator half(float);
    427 native operator float(uchar);
    428 native operator float(ushort);
    429 native operator float(uint);
    430 native operator float(char);
    431 native operator float(short);
    432 native operator float(int);
    433 native operator float(half);
    434 
    435378native float operator.x(float4);
    436379native float operator.y(float4);

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.cpp

    r246138 r246225  
    4545    for (auto& structureDefinition : program.structureDefinitions()) {
    4646        for (auto& structureElement : structureDefinition->structureElements()) {
     47            {
     48                // The getter: operator.field
     49                auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(structureElement.origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(structureElement.origin()), structureDefinition)), String(), WTF::nullopt, WTF::nullopt);
     50                AST::VariableDeclarations parameters;
     51                parameters.append(WTFMove(variableDeclaration));
     52                AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(structureElement.origin()), AST::AttributeBlock(), WTF::nullopt, structureElement.type().clone(), makeString("operator.", structureElement.name()), WTFMove(parameters), WTF::nullopt, isOperator));
     53                if (!program.append(WTFMove(nativeFunctionDeclaration)))
     54                    return false;
     55            }
     56
     57            {
     58                // The setter: operator.field=
     59                auto variableDeclaration1 = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(structureElement.origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(structureElement.origin()), structureDefinition)), String(), WTF::nullopt, WTF::nullopt);
     60                auto variableDeclaration2 = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(structureElement.origin()), AST::Qualifiers(), structureElement.type().clone(), String(), WTF::nullopt, WTF::nullopt);
     61                AST::VariableDeclarations parameters;
     62                parameters.append(WTFMove(variableDeclaration1));
     63                parameters.append(WTFMove(variableDeclaration2));
     64                AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(structureElement.origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(structureElement.origin()), structureDefinition), makeString("operator.", structureElement.name(), '='), WTFMove(parameters), WTF::nullopt, isOperator));
     65                if (!program.append(WTFMove(nativeFunctionDeclaration)))
     66                    return false;
     67            }
     68
    4769            // The ander: operator&.field
    4870            auto createAnder = [&](AST::AddressSpace addressSpace) -> AST::NativeFunctionDeclaration {
Note: See TracChangeset for help on using the changeset viewer.