Modified: trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp (246224 => 246225)
--- trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp 2019-06-07 23:59:22 UTC (rev 246224)
+++ trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp 2019-06-08 00:03:58 UTC (rev 246225)
@@ -63,6 +63,21 @@
return functionName;
}
+static String convertAddressSpace(AST::AddressSpace addressSpace)
+{
+ switch (addressSpace) {
+ case AST::AddressSpace::Constant:
+ return "constant"_str;
+ case AST::AddressSpace::Device:
+ return "device"_str;
+ case AST::AddressSpace::Threadgroup:
+ return "threadgroup"_str;
+ default:
+ ASSERT(addressSpace == AST::AddressSpace::Thread);
+ return "thread"_str;
+ }
+}
+
static String atomicName(String input)
{
if (input == "Add")
@@ -360,7 +375,7 @@
auto& fourthArgumentPointer = downcast<AST::PointerType>(*nativeFunctionDeclaration.parameters()[3]->type());
auto fourthArgumentAddressSpace = fourthArgumentPointer.addressSpace();
auto fourthArgumentPointee = typeNamer.mangledNameForType(fourthArgumentPointer.elementType());
- stringBuilder.append(makeString("void ", outputFunctionName, '(', toString(firstArgumentAddressSpace), ' ', firstArgumentPointee, "* object, ", secondArgument, " compare, ", thirdArgument, " desired, ", toString(fourthArgumentAddressSpace), ' ', fourthArgumentPointee, "* out) {\n"));
+ stringBuilder.append(makeString("void ", outputFunctionName, '(', convertAddressSpace(firstArgumentAddressSpace), ' ', firstArgumentPointee, "* object, ", secondArgument, " compare, ", thirdArgument, " desired, ", convertAddressSpace(fourthArgumentAddressSpace), ' ', fourthArgumentPointee, "* out) {\n"));
stringBuilder.append(" atomic_compare_exchange_weak_explicit(object, &compare, desired, memory_order_relaxed);\n");
stringBuilder.append(" *out = compare;\n");
stringBuilder.append("}\n");
@@ -378,7 +393,7 @@
auto thirdArgumentAddressSpace = thirdArgumentPointer.addressSpace();
auto thirdArgumentPointee = typeNamer.mangledNameForType(thirdArgumentPointer.elementType());
auto name = atomicName(nativeFunctionDeclaration.name().substring("Interlocked"_str.length()));
- stringBuilder.append(makeString("void ", outputFunctionName, '(', toString(firstArgumentAddressSpace), ' ', firstArgumentPointee, "* object, ", secondArgument, " operand, ", toString(thirdArgumentAddressSpace), ' ', thirdArgumentPointee, "* out) {\n"));
+ stringBuilder.append(makeString("void ", outputFunctionName, '(', convertAddressSpace(firstArgumentAddressSpace), ' ', firstArgumentPointee, "* object, ", secondArgument, " operand, ", convertAddressSpace(thirdArgumentAddressSpace), ' ', thirdArgumentPointee, "* out) {\n"));
stringBuilder.append(makeString(" *out = atomic_fetch_", name, "_explicit(object, operand, memory_order_relaxed);\n"));
stringBuilder.append("}\n");
return stringBuilder.toString();
Modified: trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp (246224 => 246225)
--- trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp 2019-06-07 23:59:22 UTC (rev 246224)
+++ trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp 2019-06-08 00:03:58 UTC (rev 246225)
@@ -36,7 +36,6 @@
#include "WHLSLDereferenceExpression.h"
#include "WHLSLDoWhileLoop.h"
#include "WHLSLDotExpression.h"
-#include "WHLSLEntryPointType.h"
#include "WHLSLForLoop.h"
#include "WHLSLGatherEntryPointItems.h"
#include "WHLSLIfStatement.h"
@@ -355,7 +354,7 @@
Vector<ResolvingType> argumentTypes;
Vector<std::reference_wrapper<ResolvingType>> argumentTypeReferences;
for (size_t i = 0; i < numExpectedParameters - 1; ++i)
- argumentTypes.append((*functionDefinition.parameters()[i]->type())->clone());
+ argumentTypes.append((*functionDefinition.parameters()[0]->type())->clone());
for (auto& argumentType : argumentTypes)
argumentTypeReferences.append(argumentType);
auto* overload = resolveFunctionOverloadImpl(*getterFuncs, argumentTypeReferences, nullptr);
@@ -492,8 +491,6 @@
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;
@@ -969,9 +966,9 @@
assignType(makeArrayReferenceExpression, makeUniqueRef<AST::ArrayReferenceType>(Lexer::Token(makeArrayReferenceExpression.origin()), *leftAddressSpace, leftValueType->clone()));
}
-void Checker::finishVisiting(AST::PropertyAccessExpression& propertyAccessExpression, ResolvingType* additionalArgumentType)
+void Checker::visit(AST::DotExpression& dotExpression)
{
- auto baseInfo = recurseAndGetInfo(propertyAccessExpression.base());
+ auto baseInfo = recurseAndGetInfo(dotExpression.base());
if (!baseInfo)
return;
auto baseUnnamedType = commit(baseInfo->resolvingType);
@@ -982,21 +979,18 @@
AST::UnnamedType* getterReturnType = nullptr;
{
Vector<std::reference_wrapper<ResolvingType>> getterArgumentTypes { baseInfo->resolvingType };
- if (additionalArgumentType)
- getterArgumentTypes.append(*additionalArgumentType);
- if ((getterFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleGetterOverloads(), getterArgumentTypes, nullptr)))
+ getterFunction = resolveFunctionOverloadImpl(dotExpression.possibleGetterOverloads(), getterArgumentTypes, nullptr);
+ if (getterFunction)
getterReturnType = &getterFunction->type();
}
AST::FunctionDeclaration* anderFunction = nullptr;
AST::UnnamedType* anderReturnType = nullptr;
- auto leftAddressSpace = baseInfo->typeAnnotation.leftAddressSpace();
- if (leftAddressSpace) {
- 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);
- if ((anderFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleAnderOverloads(), anderArgumentTypes, 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);
+ 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
}
@@ -1003,68 +997,47 @@
AST::FunctionDeclaration* threadAnderFunction = nullptr;
AST::UnnamedType* threadAnderReturnType = 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);
- if ((threadAnderFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleAnderOverloads(), threadAnderArgumentTypes, 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);
+ 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
}
- if (leftAddressSpace && !anderFunction && !getterFunction) {
+ if (!getterFunction && !anderFunction) {
setError();
return;
}
-
- if (!leftAddressSpace && !threadAnderFunction && !getterFunction) {
+ if (getterFunction && anderFunction) {
setError();
return;
}
-
- if (threadAnderFunction && getterFunction) {
- setError();
- return;
- }
-
if (anderFunction && threadAnderFunction && !matches(*anderReturnType, *threadAnderReturnType)) {
setError();
return;
}
- if (getterFunction && anderFunction && !matches(*getterReturnType, *anderReturnType)) {
- setError();
- return;
- }
+ AST::UnnamedType* fieldType = getterReturnType ? getterReturnType : anderReturnType;
- if (getterFunction && threadAnderFunction && !matches(*getterReturnType, *threadAnderReturnType)) {
- setError();
- return;
- }
-
- AST::UnnamedType* fieldType = getterReturnType ? getterReturnType : anderReturnType ? anderReturnType : threadAnderReturnType;
-
AST::FunctionDeclaration* setterFunction = nullptr;
AST::UnnamedType* setterReturnType = nullptr;
{
ResolvingType fieldResolvingType(fieldType->clone());
- Vector<std::reference_wrapper<ResolvingType>> setterArgumentTypes { baseInfo->resolvingType };
- if (additionalArgumentType)
- setterArgumentTypes.append(*additionalArgumentType);
- setterArgumentTypes.append(fieldResolvingType);
- setterFunction = resolveFunctionOverloadImpl(propertyAccessExpression.possibleSetterOverloads(), setterArgumentTypes, nullptr);
+ Vector<std::reference_wrapper<ResolvingType>> setterArgumentTypes { baseInfo->resolvingType, fieldResolvingType };
+ setterFunction = resolveFunctionOverloadImpl(dotExpression.possibleSetterOverloads(), setterArgumentTypes, nullptr);
if (setterFunction)
setterReturnType = &setterFunction->type();
}
- if (setterFunction && !getterFunction) {
+ if (setterFunction && anderFunction) {
setError();
return;
}
- propertyAccessExpression.setGetterFunction(getterFunction);
- propertyAccessExpression.setAnderFunction(anderFunction);
- propertyAccessExpression.setThreadAnderFunction(threadAnderFunction);
- propertyAccessExpression.setSetterFunction(setterFunction);
+ dotExpression.setGetterFunction(getterFunction);
+ dotExpression.setAnderFunction(anderFunction);
+ dotExpression.setThreadAnderFunction(threadAnderFunction);
+ dotExpression.setSetterFunction(setterFunction);
AST::TypeAnnotation typeAnnotation = AST::RightValue();
if (auto leftAddressSpace = baseInfo->typeAnnotation.leftAddressSpace()) {
@@ -1072,24 +1045,16 @@
typeAnnotation = AST::LeftValue { *leftAddressSpace };
else if (setterFunction)
typeAnnotation = AST::AbstractLeftValue();
- } else if (!baseInfo->typeAnnotation.isRightValue() && (setterFunction || threadAnderFunction))
+ } else if (!baseInfo->typeAnnotation.isRightValue() && (setterFunction || anderFunction))
typeAnnotation = AST::AbstractLeftValue();
- assignType(propertyAccessExpression, fieldType->clone(), WTFMove(typeAnnotation));
+ assignType(dotExpression, fieldType->clone(), WTFMove(typeAnnotation));
}
-void Checker::visit(AST::DotExpression& dotExpression)
+void Checker::visit(AST::IndexExpression&)
{
- finishVisiting(dotExpression);
+ // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198163 Implement this.
}
-void Checker::visit(AST::IndexExpression& indexExpression)
-{
- auto baseInfo = recurseAndGetInfo(indexExpression.indexExpression());
- if (!baseInfo)
- return;
- finishVisiting(indexExpression, &baseInfo->resolvingType);
-}
-
void Checker::visit(AST::VariableReference& variableReference)
{
ASSERT(variableReference.variable());
@@ -1397,7 +1362,7 @@
if (error())
return;
auto lastInfo = getInfo(commaExpression.list().last());
- forwardType(commaExpression, lastInfo->resolvingType);
+ forwardType(commaExpression, lastInfo->resolvingType, lastInfo->typeAnnotation);
}
void Checker::visit(AST::TernaryExpression& ternaryExpression)
Modified: trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp (246224 => 246225)
--- trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp 2019-06-07 23:59:22 UTC (rev 246224)
+++ trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp 2019-06-08 00:03:58 UTC (rev 246225)
@@ -51,11 +51,10 @@
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::PropertyAccessExpression&);
+ bool simplifyRightValue(AST::DotExpression&);
bool simplifyAbstractLeftValue(AST::AssignmentExpression&, AST::DotExpression&, UniqueRef<AST::_expression_>&& right);
void simplifyLeftValue(AST::_expression_&);
@@ -69,14 +68,6 @@
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))
- setError();
-}
-
void PropertyResolver::visit(AST::FunctionDefinition& functionDefinition)
{
Visitor::visit(functionDefinition);
@@ -84,35 +75,26 @@
functionDefinition.block().statements().insert(0, makeUniqueRef<AST::VariableDeclarationsStatement>(Lexer::Token(m_variableDeclarations[0]->origin()), WTFMove(m_variableDeclarations)));
}
-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)
+static 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)
{
- auto maybeAddIndexArgument = [&](Vector<UniqueRef<AST::_expression_>>& arguments) {
- if (!indexVariable)
- return;
- auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(*indexVariable));
- ASSERT(indexVariable->type());
- variableReference->setType(indexVariable->type()->clone());
- variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
- arguments.append(WTFMove(variableReference));
- };
-
- if (relevantAnder) {
+ if (dotExpression.anderFunction()) {
// *operator&.foo(&v) = newValue
+ if (!dotExpression.threadAnderFunction())
+ return WTF::nullopt;
+
Vector<UniqueRef<AST::_expression_>> arguments;
arguments.append(pointerToLeftValueFactory());
- maybeAddIndexArgument(arguments);
-
- auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(propertyAccessExpression.origin()), String(relevantAnder->name()), WTFMove(arguments));
- callExpression->setType(relevantAnder->type().clone());
+ auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(dotExpression.origin()), String(dotExpression.threadAnderFunction()->name()), WTFMove(arguments));
+ callExpression->setType(dotExpression.threadAnderFunction()->type().clone());
callExpression->setTypeAnnotation(AST::RightValue());
- callExpression->setFunction(*relevantAnder);
+ callExpression->setFunction(*dotExpression.threadAnderFunction());
- auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(callExpression));
- dereferenceExpression->setType(downcast<AST::PointerType>(relevantAnder->type()).elementType().clone());
+ auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(dotExpression.origin()), WTFMove(callExpression));
+ dereferenceExpression->setType(downcast<AST::PointerType>(dotExpression.threadAnderFunction()->type()).elementType().clone());
dereferenceExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
- auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(dereferenceExpression), WTFMove(newValue));
- assignmentExpression->setType(downcast<AST::PointerType>(relevantAnder->type()).elementType().clone());
+ auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(dotExpression.origin()), WTFMove(dereferenceExpression), WTFMove(newValue));
+ assignmentExpression->setType(downcast<AST::PointerType>(dotExpression.threadAnderFunction()->type()).elementType().clone());
assignmentExpression->setTypeAnnotation(AST::RightValue());
return UniqueRef<AST::_expression_>(WTFMove(assignmentExpression));
@@ -119,50 +101,39 @@
}
// v = operator.foo=(v, newValue)
- ASSERT(propertyAccessExpression.setterFunction());
+ ASSERT(dotExpression.setterFunction());
Vector<UniqueRef<AST::_expression_>> arguments;
arguments.append(leftValueFactory());
- maybeAddIndexArgument(arguments);
arguments.append(WTFMove(newValue));
-
- auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(propertyAccessExpression.origin()), String(propertyAccessExpression.setterFunction()->name()), WTFMove(arguments));
- callExpression->setType(propertyAccessExpression.setterFunction()->type().clone());
+ auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(dotExpression.origin()), String(dotExpression.setterFunction()->name()), WTFMove(arguments));
+ callExpression->setType(dotExpression.setterFunction()->type().clone());
callExpression->setTypeAnnotation(AST::RightValue());
- callExpression->setFunction(*propertyAccessExpression.setterFunction());
+ callExpression->setFunction(*dotExpression.setterFunction());
- auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(propertyAccessExpression.origin()), leftValueFactory(), WTFMove(callExpression));
- assignmentExpression->setType(propertyAccessExpression.setterFunction()->type().clone());
+ auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(dotExpression.origin()), leftValueFactory(), WTFMove(callExpression));
+ assignmentExpression->setType(dotExpression.setterFunction()->type().clone());
assignmentExpression->setTypeAnnotation(AST::RightValue());
return UniqueRef<AST::_expression_>(WTFMove(assignmentExpression));
}
-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)
+static Optional<UniqueRef<AST::_expression_>> getterCall(AST::DotExpression& dotExpression, const std::function<UniqueRef<AST::_expression_>()>& leftValueFactory, const std::function<UniqueRef<AST::_expression_>()>& pointerToLeftValueFactory)
{
- auto maybeAddIndexArgument = [&](Vector<UniqueRef<AST::_expression_>>& arguments) {
- if (!indexVariable)
- return;
- auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(*indexVariable));
- ASSERT(indexVariable->type());
- variableReference->setType(indexVariable->type()->clone());
- variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
- arguments.append(WTFMove(variableReference));
- };
-
- if (relevantAnder) {
+ if (dotExpression.anderFunction()) {
// *operator&.foo(&v)
+ if (!dotExpression.threadAnderFunction())
+ return WTF::nullopt;
+
Vector<UniqueRef<AST::_expression_>> arguments;
arguments.append(pointerToLeftValueFactory());
- maybeAddIndexArgument(arguments);
-
- auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(propertyAccessExpression.origin()), String(relevantAnder->name()), WTFMove(arguments));
- callExpression->setType(relevantAnder->type().clone());
+ auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(dotExpression.origin()), String(dotExpression.threadAnderFunction()->name()), WTFMove(arguments));
+ callExpression->setType(dotExpression.threadAnderFunction()->type().clone());
callExpression->setTypeAnnotation(AST::RightValue());
- callExpression->setFunction(*relevantAnder);
+ callExpression->setFunction(*dotExpression.threadAnderFunction());
- auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(callExpression));
- dereferenceExpression->setType(downcast<AST::PointerType>(relevantAnder->type()).elementType().clone());
+ auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(dotExpression.origin()), WTFMove(callExpression));
+ dereferenceExpression->setType(downcast<AST::PointerType>(dotExpression.threadAnderFunction()->type()).elementType().clone());
dereferenceExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
return UniqueRef<AST::_expression_>(WTFMove(dereferenceExpression));
@@ -169,16 +140,14 @@
}
// operator.foo(v)
- ASSERT(propertyAccessExpression.getterFunction());
+ ASSERT(dotExpression.getterFunction());
Vector<UniqueRef<AST::_expression_>> arguments;
arguments.append(leftValueFactory());
- maybeAddIndexArgument(arguments);
-
- auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(propertyAccessExpression.origin()), String(propertyAccessExpression.getterFunction()->name()), WTFMove(arguments));
- callExpression->setType(propertyAccessExpression.getterFunction()->type().clone());
+ auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(dotExpression.origin()), String(dotExpression.getterFunction()->name()), WTFMove(arguments));
+ callExpression->setType(dotExpression.getterFunction()->type().clone());
callExpression->setTypeAnnotation(AST::RightValue());
- callExpression->setFunction(*propertyAccessExpression.getterFunction());
+ callExpression->setFunction(*dotExpression.getterFunction());
return UniqueRef<AST::_expression_>(WTFMove(callExpression));
}
@@ -192,7 +161,7 @@
Vector<UniqueRef<AST::_expression_>> expressions;
UniqueRef<AST::_expression_> result;
};
-static Optional<ModifyResult> modify(AST::PropertyAccessExpression& propertyAccessExpression, std::function<Optional<ModificationResult>(Optional<UniqueRef<AST::_expression_>>&&)> modification)
+static Optional<ModifyResult> modify(AST::DotExpression& dotExpression, std::function<Optional<ModificationResult>(Optional<UniqueRef<AST::_expression_>>&&)> modification)
{
// Consider a.b.c.d++;
// This would get transformed into:
@@ -212,7 +181,7 @@
// r = operator.d=(r, newValue);
// q = operator.c=(q, r);
//
- // Step 5:
+ // Step 4:
// *p = operator.b=(*p, q);
// If the _expression_ is a.b.c.d = e, Step 3 disappears and "newValue" in step 4 becomes "e".
@@ -219,15 +188,15 @@
// Find the ".b" ".c" and ".d" expressions. They end up in the order [".d", ".c", ".b"].
- Vector<std::reference_wrapper<AST::PropertyAccessExpression>> chain;
- AST::PropertyAccessExpression* iterator = &propertyAccessExpression;
+ Vector<std::reference_wrapper<AST::DotExpression>> chain;
+ AST::DotExpression* iterator = &dotExpression;
while (true) {
chain.append(*iterator);
if (iterator->base().typeAnnotation().leftAddressSpace())
break;
ASSERT(!iterator->base().typeAnnotation().isRightValue());
- ASSERT(is<AST::PropertyAccessExpression>(iterator->base()));
- iterator = &downcast<AST::PropertyAccessExpression>(iterator->base());
+ ASSERT(is<AST::DotExpression>(iterator->base())); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198163 Make this work with index expressions
+ iterator = &downcast<AST::DotExpression>(iterator->base());
}
auto leftExpression = iterator->takeBase();
AST::_expression_& innerLeftExpression = leftExpression;
@@ -239,41 +208,10 @@
Vector<UniqueRef<AST::VariableDeclaration>> intermediateVariables;
intermediateVariables.reserveInitialCapacity(chain.size() - 1);
for (size_t i = 1; i < chain.size(); ++i) {
- auto& propertyAccessExpression = static_cast<AST::PropertyAccessExpression&>(chain[i]);
- intermediateVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(propertyAccessExpression.origin()), AST::Qualifiers(), propertyAccessExpression.resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt));
+ auto& dotExpression = static_cast<AST::DotExpression&>(chain[i]);
+ intermediateVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(dotExpression.origin()), AST::Qualifiers(), dotExpression.resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt));
}
- // Consider a[foo()][b] = c;
- // Naively, This would get expanded to:
- //
- // temp = operator[](a, foo());
- // temp = operator[]=(temp, b, c);
- // a = operator[]=(a, foo(), temp);
- //
- // However, if we did this, we would have to run foo() twice, which would be incorrect.
- // Instead, we need to save foo() and b into more temporary variables.
- // 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).
- //
- // Instead, this gets expanded to:
- //
- // p = &a;
- // temp = foo();
- // q = operator[](*p, temp);
- // temp2 = b;
- // q = operator[]=(q, temp2, c);
- // *p = operator[]=(*p, temp, q);
-
- Vector<Optional<UniqueRef<AST::VariableDeclaration>>> indexVariables;
- indexVariables.reserveInitialCapacity(chain.size());
- for (AST::PropertyAccessExpression& propertyAccessExpression : chain) {
- if (!is<AST::IndexExpression>(propertyAccessExpression)) {
- indexVariables.append(WTF::nullopt);
- continue;
- }
- auto& indexExpression = downcast<AST::IndexExpression>(propertyAccessExpression);
- indexVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(propertyAccessExpression.origin()), AST::Qualifiers(), indexExpression.indexExpression().resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt));
- }
-
Vector<UniqueRef<AST::_expression_>> expressions;
// Step 1:
@@ -310,7 +248,7 @@
variableReference->setType(pointerVariable->type()->clone());
variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
- auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference));
+ auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(dotExpression.origin()), WTFMove(variableReference));
ASSERT(pointerVariable->type());
dereferenceExpression->setType(downcast<AST::PointerType>(*pointerVariable->type()).elementType().clone());
dereferenceExpression->setTypeAnnotation(AST::LeftValue { downcast<AST::PointerType>(*pointerVariable->type()).addressSpace() });
@@ -323,9 +261,9 @@
variableReference->setType(previous->type()->clone());
variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
- auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference));
+ auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(dotExpression.origin()), WTFMove(variableReference));
ASSERT(previous->type());
- makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), AST::AddressSpace::Thread, previous->type()->clone()));
+ makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(dotExpression.origin()), AST::AddressSpace::Thread, previous->type()->clone()));
makePointerExpression->setTypeAnnotation(AST::RightValue());
return makePointerExpression;
}
@@ -336,33 +274,12 @@
variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
return variableReference;
};
- auto appendIndexAssignment = [&](AST::PropertyAccessExpression& propertyAccessExpression, Optional<UniqueRef<AST::VariableDeclaration>>& indexVariable) {
- if (!indexVariable)
- return;
-
- auto& indexExpression = downcast<AST::IndexExpression>(propertyAccessExpression);
-
- auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(*indexVariable));
- ASSERT(indexVariable->get().type());
- variableReference->setType(indexVariable->get().type()->clone());
- variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
-
- auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference), indexExpression.takeIndex());
- assignmentExpression->setType(indexVariable->get().type()->clone());
- assignmentExpression->setTypeAnnotation(AST::RightValue());
-
- expressions.append(WTFMove(assignmentExpression));
- };
for (size_t i = chain.size(); --i; ) {
- AST::PropertyAccessExpression& propertyAccessExpression = chain[i];
+ AST::DotExpression& dotExpression = chain[i];
AST::VariableDeclaration& variableDeclaration = intermediateVariables[i - 1];
- Optional<UniqueRef<AST::VariableDeclaration>>& indexVariable = indexVariables[i];
- appendIndexAssignment(propertyAccessExpression, indexVariable);
+ auto callExpression = getterCall(dotExpression, previousLeftValue, pointerToPreviousLeftValue);
- AST::FunctionDeclaration* relevantAnder = i == chain.size() - 1 ? propertyAccessExpression.anderFunction() : propertyAccessExpression.threadAnderFunction();
- auto callExpression = getterCall(propertyAccessExpression, relevantAnder, previousLeftValue, pointerToPreviousLeftValue, indexVariable ? &*indexVariable : nullptr);
-
if (!callExpression)
return WTF::nullopt;
@@ -371,7 +288,7 @@
variableReference->setType(variableDeclaration.type()->clone());
variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
- auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference), WTFMove(*callExpression));
+ auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(dotExpression.origin()), WTFMove(variableReference), WTFMove(*callExpression));
assignmentExpression->setType(variableDeclaration.type()->clone());
assignmentExpression->setTypeAnnotation(AST::RightValue());
@@ -379,9 +296,7 @@
previous = &variableDeclaration;
}
- appendIndexAssignment(chain[0], indexVariables[0]);
- AST::FunctionDeclaration* relevantAnder = chain.size() == 1 ? propertyAccessExpression.anderFunction() : propertyAccessExpression.threadAnderFunction();
- auto lastGetterCallExpression = getterCall(chain[0], relevantAnder, previousLeftValue, pointerToPreviousLeftValue, indexVariables[0] ? &*(indexVariables[0]) : nullptr);
+ auto lastGetterCallExpression = getterCall(chain[0], previousLeftValue, pointerToPreviousLeftValue);
// Step 3:
auto modificationResult = modification(WTFMove(lastGetterCallExpression));
@@ -394,11 +309,10 @@
UniqueRef<AST::_expression_> rightValue = WTFMove(modificationResult->result);
auto expressionType = rightValue->resolvedType().clone();
for (size_t i = 0; i < chain.size() - 1; ++i) {
- AST::PropertyAccessExpression& propertyAccessExpression = chain[i];
+ AST::DotExpression& dotExpression = chain[i];
AST::VariableDeclaration& variableDeclaration = intermediateVariables[i];
- Optional<UniqueRef<AST::VariableDeclaration>>& indexVariable = indexVariables[i];
- auto assignmentExpression = setterCall(propertyAccessExpression, propertyAccessExpression.threadAnderFunction(), WTFMove(rightValue), [&]() -> UniqueRef<AST::_expression_> {
+ auto assignmentExpression = setterCall(dotExpression, WTFMove(rightValue), [&]() -> UniqueRef<AST::_expression_> {
auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
ASSERT(variableDeclaration.type());
variableReference->setType(variableDeclaration.type()->clone());
@@ -410,12 +324,12 @@
variableReference->setType(variableDeclaration.type()->clone());
variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
- auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference));
+ auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(dotExpression.origin()), WTFMove(variableReference));
ASSERT(variableDeclaration.type());
- makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), AST::AddressSpace::Thread, variableDeclaration.type()->clone()));
+ makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(dotExpression.origin()), AST::AddressSpace::Thread, variableDeclaration.type()->clone()));
makePointerExpression->setTypeAnnotation(AST::RightValue());
return makePointerExpression;
- }, indexVariable ? &*indexVariable : nullptr);
+ });
if (!assignmentExpression)
return WTF::nullopt;
@@ -430,14 +344,13 @@
// Step 5:
{
- AST::PropertyAccessExpression& propertyAccessExpression = chain[chain.size() - 1];
- auto assignmentExpression = setterCall(propertyAccessExpression, propertyAccessExpression.anderFunction(), WTFMove(rightValue), [&]() -> UniqueRef<AST::_expression_> {
+ auto assignmentExpression = setterCall(chain[chain.size() - 1], WTFMove(rightValue), [&]() -> UniqueRef<AST::_expression_> {
auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(pointerVariable));
ASSERT(pointerVariable->type());
variableReference->setType(pointerVariable->type()->clone());
variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
- auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference));
+ auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(Lexer::Token(dotExpression.origin()), WTFMove(variableReference));
ASSERT(pointerVariable->type());
dereferenceExpression->setType(downcast<AST::PointerType>(*pointerVariable->type()).elementType().clone());
dereferenceExpression->setTypeAnnotation(AST::LeftValue { downcast<AST::PointerType>(*pointerVariable->type()).addressSpace() });
@@ -448,7 +361,7 @@
variableReference->setType(pointerVariable->type()->clone());
variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
return variableReference;
- }, indexVariables[indexVariables.size() - 1] ? &*(indexVariables[indexVariables.size() - 1]) : nullptr);
+ });
if (!assignmentExpression)
return WTF::nullopt;
@@ -460,10 +373,6 @@
variableDeclarations.append(WTFMove(pointerVariable));
for (auto& intermediateVariable : intermediateVariables)
variableDeclarations.append(WTFMove(intermediateVariable));
- for (auto& indexVariable : indexVariables) {
- if (indexVariable)
- variableDeclarations.append(WTFMove(*indexVariable));
- }
return {{ innerLeftExpression, WTFMove(expressions), WTFMove(variableDeclarations) }};
}
@@ -476,13 +385,16 @@
return;
}
ASSERT(!assignmentExpression.left().typeAnnotation().isRightValue());
- ASSERT(is<AST::PropertyAccessExpression>(assignmentExpression.left()));
+ if (!is<AST::DotExpression>(assignmentExpression.left())) {
+ setError(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198163 Make this work with index expressions.
+ return;
+ }
auto type = assignmentExpression.right().resolvedType().clone();
checkErrorAndVisit(assignmentExpression.right());
- auto modifyResult = modify(downcast<AST::PropertyAccessExpression>(assignmentExpression.left()), [&](Optional<UniqueRef<AST::_expression_>>&&) -> Optional<ModificationResult> {
+ auto modifyResult = modify(downcast<AST::DotExpression>(assignmentExpression.left()), [&](Optional<UniqueRef<AST::_expression_>>&&) -> Optional<ModificationResult> {
return {{ Vector<UniqueRef<AST::_expression_>>(), assignmentExpression.takeRight() }};
});
@@ -512,8 +424,6 @@
// newValue = ...;
// *p = newValue;
- simplifyLeftValue(readModifyWriteExpression.leftValue());
-
auto baseType = readModifyWriteExpression.leftValue().resolvedType().clone();
auto pointerType = makeUniqueRef<AST::PointerType>(Lexer::Token(readModifyWriteExpression.leftValue().origin()), *readModifyWriteExpression.leftValue().typeAnnotation().leftAddressSpace(), baseType->clone());
@@ -610,11 +520,11 @@
}
ASSERT(!readModifyWriteExpression.leftValue().typeAnnotation().isRightValue());
- if (!is<AST::PropertyAccessExpression>(readModifyWriteExpression.leftValue())) {
- setError();
+ if (!is<AST::DotExpression>(readModifyWriteExpression.leftValue())) {
+ setError(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198163 Make this work with index expressions.
return;
}
- auto modifyResult = modify(downcast<AST::PropertyAccessExpression>(readModifyWriteExpression.leftValue()), [&](Optional<UniqueRef<AST::_expression_>>&& lastGetterCallExpression) -> Optional<ModificationResult> {
+ auto modifyResult = modify(downcast<AST::DotExpression>(readModifyWriteExpression.leftValue()), [&](Optional<UniqueRef<AST::_expression_>>&& lastGetterCallExpression) -> Optional<ModificationResult> {
Vector<UniqueRef<AST::_expression_>> expressions;
if (!lastGetterCallExpression)
return WTF::nullopt;
@@ -671,150 +581,128 @@
m_variableDeclarations.append(WTFMove(newVariableDeclaration));
}
-bool PropertyResolver::simplifyRightValue(AST::PropertyAccessExpression& propertyAccessExpression)
+bool PropertyResolver::simplifyRightValue(AST::DotExpression& dotExpression)
{
- Lexer::Token origin = propertyAccessExpression.origin();
+ Lexer::Token origin = dotExpression.origin();
- checkErrorAndVisit(propertyAccessExpression.base());
+ checkErrorAndVisit(dotExpression.base());
- auto& base = propertyAccessExpression.base();
- if (auto leftAddressSpace = base.typeAnnotation().leftAddressSpace()) {
- if (auto* anderFunction = propertyAccessExpression.anderFunction()) {
- auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), propertyAccessExpression.takeBase());
+ if (auto* anderFunction = dotExpression.anderFunction()) {
+ auto& base = dotExpression.base();
+ if (auto leftAddressSpace = base.typeAnnotation().leftAddressSpace()) {
+ auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), dotExpression.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 (is<AST::IndexExpression>(propertyAccessExpression))
- arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
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>(propertyAccessExpression, WTFMove(origin), WTFMove(callExpression));
+ auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(dotExpression, 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;
}
- }
- if (propertyAccessExpression.getterFunction()) {
- auto& getterFunction = *propertyAccessExpression.getterFunction();
- Vector<UniqueRef<AST::_expression_>> arguments;
- arguments.append(propertyAccessExpression.takeBase());
- if (is<AST::IndexExpression>(propertyAccessExpression))
- arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
- 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());
- return true;
- }
+ // 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())
+ return false;
- // 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.
- ASSERT(propertyAccessExpression.threadAnderFunction());
- auto* threadAnderFunction = propertyAccessExpression.threadAnderFunction();
+ auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), base.resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt);
- auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), base.resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt);
+ auto variableReference1 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
+ variableReference1->setType(base.resolvedType().clone());
+ variableReference1->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
- auto variableReference1 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
- variableReference1->setType(base.resolvedType().clone());
- variableReference1->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
+ auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(origin), WTFMove(variableReference1), dotExpression.takeBase());
+ assignmentExpression->setType(base.resolvedType().clone());
+ assignmentExpression->setTypeAnnotation(AST::RightValue());
- auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(origin), WTFMove(variableReference1), propertyAccessExpression.takeBase());
- assignmentExpression->setType(base.resolvedType().clone());
- assignmentExpression->setTypeAnnotation(AST::RightValue());
+ auto variableReference2 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
+ variableReference2->setType(base.resolvedType().clone());
+ variableReference2->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
- auto variableReference2 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
- variableReference2->setType(base.resolvedType().clone());
- variableReference2->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
+ auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), WTFMove(variableReference2));
+ makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), AST::AddressSpace::Thread, base.resolvedType().clone()));
+ makePointerExpression->setTypeAnnotation(AST::RightValue());
- auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), WTFMove(variableReference2));
- makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), AST::AddressSpace::Thread, base.resolvedType().clone()));
- makePointerExpression->setTypeAnnotation(AST::RightValue());
+ Vector<UniqueRef<AST::_expression_>> arguments;
+ arguments.append(WTFMove(makePointerExpression));
+ 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);
- Vector<UniqueRef<AST::_expression_>> arguments;
- arguments.append(WTFMove(makePointerExpression));
- if (is<AST::IndexExpression>(propertyAccessExpression))
- arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
- auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(threadAnderFunction->name()), WTFMove(arguments));
- callExpression->setType(threadAnderFunction->type().clone());
- callExpression->setTypeAnnotation(AST::RightValue());
- callExpression->setFunction(*threadAnderFunction);
+ auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(WTFMove(origin), WTFMove(callExpression));
+ dereferenceExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
+ dereferenceExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
- auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(WTFMove(origin), WTFMove(callExpression));
- dereferenceExpression->setType(downcast<AST::PointerType>(threadAnderFunction->type()).elementType().clone());
- dereferenceExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
+ Vector<UniqueRef<AST::_expression_>> expressions;
+ expressions.append(WTFMove(assignmentExpression));
+ expressions.append(WTFMove(dereferenceExpression));
+ auto* commaExpression = AST::replaceWith<AST::CommaExpression>(dotExpression, WTFMove(origin), WTFMove(expressions));
+ commaExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
+ commaExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
- Vector<UniqueRef<AST::_expression_>> expressions;
- expressions.append(WTFMove(assignmentExpression));
- expressions.append(WTFMove(dereferenceExpression));
- auto* commaExpression = AST::replaceWith<AST::CommaExpression>(propertyAccessExpression, WTFMove(origin), WTFMove(expressions));
- commaExpression->setType(downcast<AST::PointerType>(threadAnderFunction->type()).elementType().clone());
- commaExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
+ m_variableDeclarations.append(WTFMove(variableDeclaration));
+ return true;
+ }
- m_variableDeclarations.append(WTFMove(variableDeclaration));
+ ASSERT(dotExpression.getterFunction());
+ auto& getterFunction = *dotExpression.getterFunction();
+ Vector<UniqueRef<AST::_expression_>> arguments;
+ arguments.append(dotExpression.takeBase());
+ auto* callExpression = AST::replaceWith<AST::CallExpression>(dotExpression, WTFMove(origin), String(getterFunction.name()), WTFMove(arguments));
+ callExpression->setFunction(getterFunction);
+ callExpression->setType(getterFunction.type().clone());
+ callExpression->setTypeAnnotation(AST::RightValue());
return true;
-
}
class LeftValueSimplifier : public Visitor {
-private:
+public:
void visit(AST::DotExpression&) override;
- void visit(AST::IndexExpression&) override;
void visit(AST::DereferenceExpression&) override;
- void finishVisiting(AST::PropertyAccessExpression&);
+private:
};
-void LeftValueSimplifier::finishVisiting(AST::PropertyAccessExpression& propertyAccessExpression)
+void LeftValueSimplifier::visit(AST::DotExpression& dotExpression)
{
- ASSERT(propertyAccessExpression.base().typeAnnotation().leftAddressSpace());
- ASSERT(propertyAccessExpression.anderFunction());
+ Visitor::visit(dotExpression);
+ ASSERT(dotExpression.base().typeAnnotation().leftAddressSpace());
+ ASSERT(dotExpression.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());
+ 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());
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 (is<AST::IndexExpression>(propertyAccessExpression))
- arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
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>(propertyAccessExpression, WTFMove(origin), WTFMove(callExpression));
+ auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(dotExpression, 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);
-}
-
-void LeftValueSimplifier::visit(AST::IndexExpression& indexExpression)
-{
- Visitor::visit(indexExpression);
- PropertyResolver().Visitor::visit(indexExpression.indexExpression());
- finishVisiting(indexExpression);
-}
-
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);
}
