Attachment 373413 Details for Bug 199462 – Patch

[patch] Patch

bug-199462-20190703135154.patch (text/plain), 41.46 KB, created by Robin Morisset on 2019-07-03 13:51:56 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Robin Morisset

Created: 2019-07-03 13:51:56 PDT

Size: 41.46 KB

patch

obsolete

>Subversion Revision: 247100
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 45456eeea975129a1a34f4fd913ce7e2f3587431..ba18ab1aa7b213753e80ff334b41e1758746af16 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,55 @@
>+2019-07-03  Robin Morisset  <rmorisset@apple.com>
>+
>+        [WHLSL] "Semantic" should be held by a unique_ptr, not an Optional
>+        https://bugs.webkit.org/show_bug.cgi?id=199462
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Most StructureElement, FunctionDeclaration and (especially) VariableDeclaration don't have a 'Semantic' field.
>+        Using an Optional<Semantic> to represent this is a major memory waste, as Semantic is 56 bytes, so Optional<Semantic> is 64 bytes!
>+        Putting one level of indirection through a unique_ptr thus saves 56 bytes for each VariableDeclaration (and FunctionDeclaration and StructureElement) that does not have a Semantic,
>+        at the low cost of one pointer dereference when accessing the field for those that have one.
>+
>+        This patch also reorders the fields of FunctionDefinition to save another 8 bytes.
>+
>+        No new tests as there is no intended functional change.
>+
>+        * Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h:
>+        (WebCore::WHLSL::AST::FunctionDeclaration::FunctionDeclaration):
>+        (WebCore::WHLSL::AST::FunctionDeclaration::semantic):
>+        * Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h:
>+        (WebCore::WHLSL::AST::ReadModifyWriteExpression::ReadModifyWriteExpression):
>+        * Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h:
>+        (WebCore::WHLSL::AST::StructureElement::StructureElement):
>+        (WebCore::WHLSL::AST::StructureElement::semantic):
>+        * Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h:
>+        (WebCore::WHLSL::AST::VariableDeclaration::VariableDeclaration):
>+        (WebCore::WHLSL::AST::VariableDeclaration::semantic):
>+        * Modules/webgpu/WHLSL/WHLSLChecker.cpp:
>+        (WebCore::WHLSL::resolveWithOperatorAnderIndexer):
>+        (WebCore::WHLSL::resolveWithOperatorLength):
>+        (WebCore::WHLSL::resolveWithReferenceComparator):
>+        * Modules/webgpu/WHLSL/WHLSLGatherEntryPointItems.cpp:
>+        (WebCore::WHLSL::Gatherer::visit):
>+        (WebCore::WHLSL::gatherEntryPointItems):
>+        * Modules/webgpu/WHLSL/WHLSLParser.cpp:
>+        (WebCore::WHLSL::Parser::parseSemantic):
>+        * Modules/webgpu/WHLSL/WHLSLParser.h:
>+        * Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp:
>+        (WebCore::WHLSL::preserveVariableLifetimes):
>+        * Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp:
>+        (WebCore::WHLSL::wrapAnderCallArgument):
>+        (WebCore::WHLSL::modify):
>+        (WebCore::WHLSL::PropertyResolver::visit):
>+        * Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp:
>+        (WebCore::WHLSL::synthesizeArrayOperatorLength):
>+        * Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp:
>+        (WebCore::WHLSL::synthesizeConstructors):
>+        * Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.cpp:
>+        (WebCore::WHLSL::synthesizeEnumerationFunctions):
>+        * Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.cpp:
>+        (WebCore::WHLSL::synthesizeStructureAccessors):
>+
> 2019-07-03  Wenson Hsieh  <wenson_hsieh@apple.com>
> 
>         REGRESSION (iOS 13): Tapping an element with a click event handler no longer clears the selection
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h
>index 52ab6a556d1fe53bdaf2d32e6584b71b6f566401..0c0304b345bd55cb5f580632f1574524969a11a7 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h
>@@ -45,15 +45,15 @@ namespace AST {
> 
> class FunctionDeclaration : public Node {
> public:
>-    FunctionDeclaration(Lexer::Token&& origin, AttributeBlock&& attributeBlock, Optional<EntryPointType> entryPointType, UniqueRef<UnnamedType>&& type, String&& name, VariableDeclarations&& parameters, Optional<Semantic>&& semantic, bool isOperator)
>+    FunctionDeclaration(Lexer::Token&& origin, AttributeBlock&& attributeBlock, Optional<EntryPointType> entryPointType, UniqueRef<UnnamedType>&& type, String&& name, VariableDeclarations&& parameters, std::unique_ptr<Semantic>&& semantic, bool isOperator)
>         : m_origin(WTFMove(origin))
>         , m_attributeBlock(WTFMove(attributeBlock))
>         , m_entryPointType(entryPointType)
>+        , m_isOperator(WTFMove(isOperator))
>         , m_type(WTFMove(type))
>         , m_name(WTFMove(name))
>         , m_parameters(WTFMove(parameters))
>         , m_semantic(WTFMove(semantic))
>-        , m_isOperator(WTFMove(isOperator))
>     {
>     }
> 
>@@ -74,7 +74,7 @@ public:
>     bool isCast() const { return m_name == "operator cast"; }
>     const VariableDeclarations& parameters() const { return m_parameters; }
>     VariableDeclarations& parameters() { return m_parameters; }
>-    Optional<Semantic>& semantic() { return m_semantic; }
>+    Semantic* semantic() { return m_semantic.get(); }
>     bool isOperator() const { return m_isOperator; }
>     Lexer::Token origin() { return m_origin; }
> 
>@@ -82,11 +82,11 @@ private:
>     Lexer::Token m_origin;
>     AttributeBlock m_attributeBlock;
>     Optional<EntryPointType> m_entryPointType;
>+    bool m_isOperator;
>     UniqueRef<UnnamedType> m_type;
>     String m_name;
>     VariableDeclarations m_parameters;
>-    Optional<Semantic> m_semantic;
>-    bool m_isOperator;
>+    std::unique_ptr<Semantic> m_semantic;
> };
> 
> } // namespace AST
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h
>index 45e3cfa702ac8d54c3e5ad836ba19b5ab3078867..17e109a29b428df0bf4e64c7592af25eed356ed0 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h
>@@ -118,8 +118,8 @@ private:
>     ReadModifyWriteExpression(Lexer::Token&& origin, UniqueRef<Expression> leftValue)
>         : Expression(Lexer::Token(origin))
>         , m_leftValue(WTFMove(leftValue))
>-        , m_oldValue(makeUniqueRef<VariableDeclaration>(Lexer::Token(origin), Qualifiers(), WTF::nullopt, String(), WTF::nullopt, nullptr))
>-        , m_newValue(makeUniqueRef<VariableDeclaration>(WTFMove(origin), Qualifiers(), WTF::nullopt, String(), WTF::nullopt, nullptr))
>+        , m_oldValue(makeUniqueRef<VariableDeclaration>(Lexer::Token(origin), Qualifiers(), WTF::nullopt, String(), nullptr, nullptr))
>+        , m_newValue(makeUniqueRef<VariableDeclaration>(WTFMove(origin), Qualifiers(), WTF::nullopt, String(), nullptr, nullptr))
>     {
>     }
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h
>index 8472f5c962c87cae0d7170ef438ed47dabdd039b..4e40ba62fd9f99f76e945fd388c2f4fb9cf31522 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h
>@@ -42,7 +42,7 @@ namespace AST {
> 
> class StructureElement : public Node {
> public:
>-    StructureElement(Lexer::Token&& origin, Qualifiers&& qualifiers, UniqueRef<UnnamedType>&& type, String&& name, Optional<Semantic> semantic)
>+    StructureElement(Lexer::Token&& origin, Qualifiers&& qualifiers, UniqueRef<UnnamedType>&& type, String&& name, std::unique_ptr<Semantic>&& semantic)
>         : m_origin(WTFMove(origin))
>         , m_qualifiers(WTFMove(qualifiers))
>         , m_type(WTFMove(type))
>@@ -59,14 +59,14 @@ public:
>     const Lexer::Token& origin() const { return m_origin; }
>     UnnamedType& type() { return m_type; }
>     const String& name() { return m_name; }
>-    Optional<Semantic>& semantic() { return m_semantic; }
>+    Semantic* semantic() { return m_semantic.get(); }
> 
> private:
>     Lexer::Token m_origin;
>     Qualifiers m_qualifiers;
>     UniqueRef<UnnamedType> m_type;
>     String m_name;
>-    Optional<Semantic> m_semantic;
>+    std::unique_ptr<Semantic> m_semantic;
> };
> 
> using StructureElements = Vector<StructureElement>;
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h
>index be0a058a1fcd50e4f67f95cc4221fc9743e30f5c..6a4393a8a29ab202bf5ba21b2cf4bddb4f68cdae 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h
>@@ -47,7 +47,7 @@ namespace AST {
> class VariableDeclaration : public Value {
>     using Base = Value;
> public:
>-    VariableDeclaration(Lexer::Token&& origin, Qualifiers&& qualifiers, Optional<UniqueRef<UnnamedType>>&& type, String&& name, Optional<Semantic>&& semantic, std::unique_ptr<Expression>&& initializer)
>+    VariableDeclaration(Lexer::Token&& origin, Qualifiers&& qualifiers, Optional<UniqueRef<UnnamedType>>&& type, String&& name, std::unique_ptr<Semantic>&& semantic, std::unique_ptr<Expression>&& initializer)
>         : Base(WTFMove(origin))
>         , m_qualifiers(WTFMove(qualifiers))
>         , m_type(WTFMove(type))
>@@ -74,7 +74,7 @@ public:
>     }
>     const Optional<UniqueRef<UnnamedType>>& type() const { return m_type; }
>     UnnamedType* type() { return m_type ? &*m_type : nullptr; }
>-    Optional<Semantic>& semantic() { return m_semantic; }
>+    Semantic* semantic() { return m_semantic.get(); }
>     Expression* initializer() { return m_initializer.get(); }
>     bool isAnonymous() const { return m_name.isNull(); }
>     std::unique_ptr<Expression> takeInitializer() { return WTFMove(m_initializer); }
>@@ -89,7 +89,7 @@ private:
>     Qualifiers m_qualifiers;
>     Optional<UniqueRef<UnnamedType>> m_type;
>     String m_name;
>-    Optional<Semantic> m_semantic;
>+    std::unique_ptr<Semantic> m_semantic;
>     std::unique_ptr<Expression> m_initializer;
> };
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>index 22bf60bc818b8179810bbe512fa9dc4cf9927ee4..eb1fa983bdd6daf0378ce9a29cb7da865417f338 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>@@ -122,9 +122,9 @@ static AST::NativeFunctionDeclaration resolveWithOperatorAnderIndexer(Lexer::Tok
>     const bool isOperator = true;
>     auto returnType = makeUniqueRef<AST::PointerType>(Lexer::Token(origin), firstArgument.addressSpace(), firstArgument.elementType().clone());
>     AST::VariableDeclarations parameters;
>-    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), firstArgument.clone(), String(), WTF::nullopt, nullptr));
>-    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(origin), intrinsics.uintType())), String(), WTF::nullopt, nullptr));
>-    return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator&[]", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
>+    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), firstArgument.clone(), String(), nullptr, nullptr));
>+    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(origin), intrinsics.uintType())), String(), nullptr, nullptr));
>+    return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator&[]", String::ConstructFromLiteral), WTFMove(parameters), nullptr, isOperator));
> }
> 
> static AST::NativeFunctionDeclaration resolveWithOperatorLength(Lexer::Token origin, AST::UnnamedType& firstArgument, const Intrinsics& intrinsics)
>@@ -132,8 +132,8 @@ static AST::NativeFunctionDeclaration resolveWithOperatorLength(Lexer::Token ori
>     const bool isOperator = true;
>     auto returnType = AST::TypeReference::wrap(Lexer::Token(origin), intrinsics.uintType());
>     AST::VariableDeclarations parameters;
>-    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), firstArgument.clone(), String(), WTF::nullopt, nullptr));
>-    return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator.length", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
>+    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), firstArgument.clone(), String(), nullptr, nullptr));
>+    return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator.length", String::ConstructFromLiteral), WTFMove(parameters), nullptr, isOperator));
> }
> 
> static AST::NativeFunctionDeclaration resolveWithReferenceComparator(Lexer::Token origin, ResolvingType& firstArgument, ResolvingType& secondArgument, const Intrinsics& intrinsics)
>@@ -153,9 +153,9 @@ static AST::NativeFunctionDeclaration resolveWithReferenceComparator(Lexer::Toke
>         }));
>     }));
>     AST::VariableDeclarations parameters;
>-    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), argumentType->clone(), String(), WTF::nullopt, nullptr));
>-    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(WTFMove(argumentType)), String(), WTF::nullopt, nullptr));
>-    return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator==", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
>+    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), argumentType->clone(), String(), nullptr, nullptr));
>+    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(WTFMove(argumentType)), String(), nullptr, nullptr));
>+    return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator==", String::ConstructFromLiteral), WTFMove(parameters), nullptr, isOperator));
> }
> 
> enum class Acceptability {
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLGatherEntryPointItems.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLGatherEntryPointItems.cpp
>index aa249c02b72686151b7cd9856630d1c31ffce790..7274536def66bff519fb693c3f7d9cadc89f80b2 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLGatherEntryPointItems.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLGatherEntryPointItems.cpp
>@@ -97,7 +97,7 @@ public:
> 
>         for (auto& structureElement : structureDefinition.structureElements()) {
>             if (structureElement.semantic())
>-                m_currentSemantic = &*structureElement.semantic();
>+                m_currentSemantic = structureElement.semantic();
>             m_path.append(structureElement.name());
>             checkErrorAndVisit(structureElement);
>             m_path.takeLast();
>@@ -149,7 +149,7 @@ public:
>     {
>         ASSERT(!m_currentSemantic);
>         if (variableDeclaration.semantic())
>-            m_currentSemantic = &*variableDeclaration.semantic();
>+            m_currentSemantic = variableDeclaration.semantic();
>         ASSERT(variableDeclaration.type());
>         m_path.append(variableDeclaration.name());
>         checkErrorAndVisit(*variableDeclaration.type());
>@@ -174,7 +174,7 @@ Optional<EntryPointItems> gatherEntryPointItems(const Intrinsics& intrinsics, AS
>         if (inputGatherer.error())
>             return WTF::nullopt;
>     }
>-    Gatherer outputGatherer(intrinsics, functionDefinition.semantic() ? &*functionDefinition.semantic() : nullptr);
>+    Gatherer outputGatherer(intrinsics, functionDefinition.semantic());
>     if (*functionDefinition.entryPointType() != AST::EntryPointType::Compute)
>         outputGatherer.checkErrorAndVisit(functionDefinition.type());
>     if (outputGatherer.error())
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>index 75a0874f43d6891a77a0ae811ed17dfb8254736e..40f269df1e308505b59720b23e72b6752a64f08b 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>@@ -688,28 +688,28 @@ auto Parser::parseStageInOutSemantic() -> Expected<AST::StageInOutSemantic, Erro
>     return AST::StageInOutSemantic(WTFMove(*origin), *index);
> }
> 
>-auto Parser::parseSemantic() -> Expected<Optional<AST::Semantic>, Error>
>+auto Parser::parseSemantic() -> Expected<std::unique_ptr<AST::Semantic>, Error>
> {
>     if (!tryType(Lexer::Token::Type::Colon))
>-        return { WTF::nullopt };
>+        return { nullptr };
> 
>     PEEK(token);
>     switch (token->type) {
>     case Lexer::Token::Type::Attribute: {
>         PARSE(result, StageInOutSemantic);
>-        return { AST::Semantic(WTFMove(*result)) };
>+        return { std::make_unique<AST::Semantic>(WTFMove(*result)) };
>     }
>     case Lexer::Token::Type::Specialized:  {
>         PARSE(result, SpecializationConstantSemantic);
>-        return { AST::Semantic(WTFMove(*result)) };
>+        return { std::make_unique<AST::Semantic>(WTFMove(*result)) };
>     }
>     case Lexer::Token::Type::Register:  {
>         PARSE(result, ResourceSemantic);
>-        return { AST::Semantic(WTFMove(*result)) };
>+        return { std::make_unique<AST::Semantic>(WTFMove(*result)) };
>     }
>     default:  {
>         PARSE(result, BuiltInSemantic);
>-        return { AST::Semantic(WTFMove(*result)) };
>+        return { std::make_unique<AST::Semantic>(WTFMove(*result)) };
>     }
>     }
> }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h
>index 276e1c5e546b6326abfe20430bbc3202158784d3..6575dd6c402e0d03a7fd00bd6622b035a4db0210 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h
>@@ -175,7 +175,7 @@ private:
>     Expected<AST::ResourceSemantic, Error> parseResourceSemantic();
>     Expected<AST::SpecializationConstantSemantic, Error> parseSpecializationConstantSemantic();
>     Expected<AST::StageInOutSemantic, Error> parseStageInOutSemantic();
>-    Expected<Optional<AST::Semantic>, Error> parseSemantic();
>+    Expected<std::unique_ptr<AST::Semantic>, Error> parseSemantic();
>     AST::Qualifiers parseQualifiers();
>     Expected<AST::StructureElement, Error> parseStructureElement();
>     Expected<AST::StructureDefinition, Error> parseStructureDefinition();
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp
>index fc754bbb2fbbaaf6059c68349847afc2b0c96838..e118c08e8fea7951618a6569fedf67e8f8011868 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp
>@@ -134,7 +134,7 @@ public:
>         bool isEntryPoint = !!functionDefinition.entryPointType();
>         if (isEntryPoint) {
>             auto structVariableDeclaration = makeUniqueRef<AST::VariableDeclaration>(functionDefinition.origin(), AST::Qualifiers(),
>-                m_structType->clone(), String(), WTF::nullopt, nullptr);
>+                m_structType->clone(), String(), nullptr, nullptr);
> 
>             auto structVariableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(structVariableDeclaration));
>             structVariableReference->setType(m_structType->clone());
>@@ -149,7 +149,7 @@ public:
>             makePointerExpression->setTypeAnnotation(AST::RightValue());
> 
>             auto pointerDeclaration = makeUniqueRef<AST::VariableDeclaration>(functionDefinition.origin(), AST::Qualifiers(),
>-                m_pointerToStructType->clone(), "wrapper"_s, WTF::nullopt, WTFMove(makePointerExpression));
>+                m_pointerToStructType->clone(), "wrapper"_s, nullptr, WTFMove(makePointerExpression));
>             m_structVariable = &pointerDeclaration;
> 
>             AST::VariableDeclarations pointerVariableDeclarations;
>@@ -160,7 +160,7 @@ public:
>             functionDefinition.block().statements().insert(1, WTFMove(pointerDeclarationStatement));
>         } else {
>             auto pointerDeclaration = makeUniqueRef<AST::VariableDeclaration>(functionDefinition.origin(), AST::Qualifiers(),
>-                m_pointerToStructType->clone(), "wrapper"_s, WTF::nullopt, nullptr);
>+                m_pointerToStructType->clone(), "wrapper"_s, nullptr, nullptr);
>             m_structVariable = &pointerDeclaration;
>             functionDefinition.parameters().append(WTFMove(pointerDeclaration));
>         }
>@@ -255,7 +255,7 @@ void preserveVariableLifetimes(Program& program)
>     for (auto& pair : escapedVariables) {
>         auto* variable = pair.key;
>         String name = pair.value;
>-        elements.append(AST::StructureElement { Lexer::Token(variable->origin()), { }, variable->type()->clone(), WTFMove(name), WTF::nullopt });
>+        elements.append(AST::StructureElement { Lexer::Token(variable->origin()), { }, variable->type()->clone(), WTFMove(name), nullptr });
>     }
> 
>     // Name of this doesn't matter, since we don't use struct names when
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp
>index 17fb0954c7ad8ffb19291e477daafe8c5dd05cfc..775d1937d9770197005c928d7b12397f4141a3a4 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp
>@@ -108,7 +108,7 @@ static Optional<AnderCallArgumentResult> wrapAnderCallArgument(UniqueRef<AST::Ex
>     }
>     if (threadAnderFunction) {
>         auto origin = expression->origin();
>-        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), baseType->clone(), String(), WTF::nullopt, nullptr);
>+        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), baseType->clone(), String(), nullptr, nullptr);
> 
>         auto variableReference1 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
>         variableReference1->setType(baseType->clone());
>@@ -312,14 +312,14 @@ static Optional<ModifyResult> modify(AST::PropertyAccessExpression& propertyAcce
>     AST::Expression& innerLeftExpression = leftExpression;
> 
>     // Create "p" variable.
>-    auto pointerVariable = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(leftExpression->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(makeUniqueRef<AST::PointerType>(Lexer::Token(leftExpression->origin()), *leftExpression->typeAnnotation().leftAddressSpace(), leftExpression->resolvedType().clone())), String(), WTF::nullopt, nullptr);
>+    auto pointerVariable = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(leftExpression->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(makeUniqueRef<AST::PointerType>(Lexer::Token(leftExpression->origin()), *leftExpression->typeAnnotation().leftAddressSpace(), leftExpression->resolvedType().clone())), String(), nullptr, nullptr);
> 
>     // Create "q" and "r" variables.
>     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, nullptr));
>+        intermediateVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(propertyAccessExpression.origin()), AST::Qualifiers(), propertyAccessExpression.resolvedType().clone(), String(), nullptr, nullptr));
>     }
> 
>     // Consider a[foo()][b] = c;
>@@ -350,7 +350,7 @@ static Optional<ModifyResult> modify(AST::PropertyAccessExpression& propertyAcce
>             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, nullptr));
>+        indexVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(propertyAccessExpression.origin()), AST::Qualifiers(), indexExpression.indexExpression().resolvedType().clone(), String(), nullptr, nullptr));
>     }
> 
>     Vector<UniqueRef<AST::Expression>> expressions;
>@@ -562,7 +562,7 @@ void PropertyResolver::visit(AST::ReadModifyWriteExpression& readModifyWriteExpr
>         auto baseType = readModifyWriteExpression.leftValue().resolvedType().clone();
>         auto pointerType = makeUniqueRef<AST::PointerType>(Lexer::Token(readModifyWriteExpression.leftValue().origin()), *readModifyWriteExpression.leftValue().typeAnnotation().leftAddressSpace(), baseType->clone());
> 
>-        auto pointerVariable = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(readModifyWriteExpression.leftValue().origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(pointerType->clone()), String(), WTF::nullopt, nullptr);
>+        auto pointerVariable = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(readModifyWriteExpression.leftValue().origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(pointerType->clone()), String(), nullptr, nullptr);
> 
>         Vector<UniqueRef<AST::Expression>> expressions;
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp
>index 9ad7fc50ea49d0a5ed071ae5c38ef3e51818368b..efbe172e62da228d4f59277d723af93940a50d8a 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp
>@@ -65,10 +65,10 @@ bool synthesizeArrayOperatorLength(Program& program)
>     bool isOperator = true;
> 
>     for (auto& arrayType : arrayTypes) {
>-        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(arrayType.get().origin()), AST::Qualifiers(), arrayType.get().clone(), String(), WTF::nullopt, nullptr);
>+        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(arrayType.get().origin()), AST::Qualifiers(), arrayType.get().clone(), String(), nullptr, nullptr);
>         AST::VariableDeclarations parameters;
>         parameters.append(WTFMove(variableDeclaration));
>-        AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(arrayType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(arrayType.get().origin()), program.intrinsics().uintType()), "operator.length"_str, WTFMove(parameters), WTF::nullopt, isOperator));
>+        AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(arrayType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(arrayType.get().origin()), program.intrinsics().uintType()), "operator.length"_str, WTFMove(parameters), nullptr, isOperator));
>         if (!program.append(WTFMove(nativeFunctionDeclaration)))
>             return false;
>     }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp
>index 0031f99f985b1fb46b1b70c703588f834d4513d7..572c9896780724ec233234cb38b2c6baa9ac63b2 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp
>@@ -157,13 +157,13 @@ bool synthesizeConstructors(Program& program)
>     for (auto& unnamedTypeKey : unnamedTypes) {
>         auto& unnamedType = unnamedTypeKey.unnamedType();
> 
>-        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(unnamedType.origin()), AST::Qualifiers(), unnamedType.clone(), String(), WTF::nullopt, nullptr);
>+        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(unnamedType.origin()), AST::Qualifiers(), unnamedType.clone(), String(), nullptr, nullptr);
>         AST::VariableDeclarations parameters;
>         parameters.append(WTFMove(variableDeclaration));
>-        AST::NativeFunctionDeclaration copyConstructor(AST::FunctionDeclaration(Lexer::Token(unnamedType.origin()), AST::AttributeBlock(), WTF::nullopt, unnamedType.clone(), "operator cast"_str, WTFMove(parameters), WTF::nullopt, isOperator));
>+        AST::NativeFunctionDeclaration copyConstructor(AST::FunctionDeclaration(Lexer::Token(unnamedType.origin()), AST::AttributeBlock(), WTF::nullopt, unnamedType.clone(), "operator cast"_str, WTFMove(parameters), nullptr, isOperator));
>         program.append(WTFMove(copyConstructor));
> 
>-        AST::NativeFunctionDeclaration defaultConstructor(AST::FunctionDeclaration(Lexer::Token(unnamedType.origin()), AST::AttributeBlock(), WTF::nullopt, unnamedType.clone(), "operator cast"_str, AST::VariableDeclarations(), WTF::nullopt, isOperator));
>+        AST::NativeFunctionDeclaration defaultConstructor(AST::FunctionDeclaration(Lexer::Token(unnamedType.origin()), AST::AttributeBlock(), WTF::nullopt, unnamedType.clone(), "operator cast"_str, AST::VariableDeclarations(), nullptr, isOperator));
>         if (!program.append(WTFMove(defaultConstructor)))
>             return false;
>     }
>@@ -174,10 +174,10 @@ bool synthesizeConstructors(Program& program)
>         if (is<AST::NativeTypeDeclaration>(static_cast<AST::NamedType&>(namedType)) && downcast<AST::NativeTypeDeclaration>(static_cast<AST::NamedType&>(namedType)).isAtomic())
>             continue;
> 
>-        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(namedType.get().origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get())), String(), WTF::nullopt, nullptr);
>+        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(namedType.get().origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get())), String(), nullptr, nullptr);
>         AST::VariableDeclarations parameters;
>         parameters.append(WTFMove(variableDeclaration));
>-        AST::NativeFunctionDeclaration copyConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, WTFMove(parameters), WTF::nullopt, isOperator));
>+        AST::NativeFunctionDeclaration copyConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, WTFMove(parameters), nullptr, isOperator));
>         program.append(WTFMove(copyConstructor));
> 
>         if (is<AST::NativeTypeDeclaration>(static_cast<AST::NamedType&>(namedType))) {
>@@ -185,7 +185,7 @@ bool synthesizeConstructors(Program& program)
>             if (nativeTypeDeclaration.isOpaqueType())
>                 continue;
>         }
>-        AST::NativeFunctionDeclaration defaultConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, AST::VariableDeclarations(), WTF::nullopt, isOperator));
>+        AST::NativeFunctionDeclaration defaultConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, AST::VariableDeclarations(), nullptr, isOperator));
>         if (!program.append(WTFMove(defaultConstructor)))
>             return false;
>     }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.cpp
>index af74160dfcbded8982d1bc8e14e908fe0c5f05e7..dd65291c5d2cc5aa030a02063fe9731cba61ded5 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.cpp
>@@ -41,39 +41,39 @@ bool synthesizeEnumerationFunctions(Program& program)
>     bool isOperator = true;
>     for (auto& enumerationDefinition : program.enumerationDefinitions()) {
>         {
>-            auto variableDeclaration1 = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), WTF::nullopt, nullptr);
>-            auto variableDeclaration2 = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), WTF::nullopt, nullptr);
>+            auto variableDeclaration1 = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), nullptr, nullptr);
>+            auto variableDeclaration2 = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), nullptr, nullptr);
>             AST::VariableDeclarations parameters;
>             parameters.append(WTFMove(variableDeclaration1));
>             parameters.append(WTFMove(variableDeclaration2));
>-            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), program.intrinsics().boolType()), "operator=="_str, WTFMove(parameters), WTF::nullopt, isOperator));
>+            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), program.intrinsics().boolType()), "operator=="_str, WTFMove(parameters), nullptr, isOperator));
>             if (!program.append(WTFMove(nativeFunctionDeclaration)))
>                 return false;
>         }
> 
>         {
>-            auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), WTF::nullopt, nullptr);
>+            auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), nullptr, nullptr);
>             AST::VariableDeclarations parameters;
>             parameters.append(WTFMove(variableDeclaration));
>-            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, enumerationDefinition->type().clone(), "operator.value"_str, WTFMove(parameters), WTF::nullopt, isOperator));
>+            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, enumerationDefinition->type().clone(), "operator.value"_str, WTFMove(parameters), nullptr, isOperator));
>             if (!program.append(WTFMove(nativeFunctionDeclaration)))
>                 return false;
>         }
> 
>         {
>-            auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), WTF::nullopt, nullptr);
>+            auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), nullptr, nullptr);
>             AST::VariableDeclarations parameters;
>             parameters.append(WTFMove(variableDeclaration));
>-            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, enumerationDefinition->type().clone(), "operator cast"_str, WTFMove(parameters), WTF::nullopt, isOperator));
>+            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, enumerationDefinition->type().clone(), "operator cast"_str, WTFMove(parameters), nullptr, isOperator));
>             if (!program.append(WTFMove(nativeFunctionDeclaration)))
>                 return false;
>         }
> 
>         {
>-            auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), enumerationDefinition->type().clone(), String(), WTF::nullopt, nullptr);
>+            auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), enumerationDefinition->type().clone(), String(), nullptr, nullptr);
>             AST::VariableDeclarations parameters;
>             parameters.append(WTFMove(variableDeclaration));
>-            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), "operator cast"_str, WTFMove(parameters), WTF::nullopt, isOperator));
>+            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), "operator cast"_str, WTFMove(parameters), nullptr, isOperator));
>             if (!program.append(WTFMove(nativeFunctionDeclaration)))
>                 return false;
>         }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.cpp
>index 29a6fdb5cbf05aa3756107fe37cac4bd3d71c630..6d7980927f39e06979ff8e1e7683653af42b9586 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.cpp
>@@ -47,11 +47,11 @@ bool synthesizeStructureAccessors(Program& program)
>             // The ander: operator&.field
>             auto createAnder = [&](AST::AddressSpace addressSpace) -> AST::NativeFunctionDeclaration {
>                 auto argumentType = makeUniqueRef<AST::PointerType>(Lexer::Token(structureElement.origin()), addressSpace, AST::TypeReference::wrap(Lexer::Token(structureElement.origin()), structureDefinition));
>-                auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(structureElement.origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(WTFMove(argumentType)), String(), WTF::nullopt, nullptr);
>+                auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(structureElement.origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(WTFMove(argumentType)), String(), nullptr, nullptr);
>                 AST::VariableDeclarations parameters;
>                 parameters.append(WTFMove(variableDeclaration));
>                 auto returnType = makeUniqueRef<AST::PointerType>(Lexer::Token(structureElement.origin()), addressSpace, structureElement.type().clone());
>-                AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(structureElement.origin()), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), makeString("operator&.", structureElement.name()), WTFMove(parameters), WTF::nullopt, isOperator));
>+                AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(structureElement.origin()), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), makeString("operator&.", structureElement.name()), WTFMove(parameters), nullptr, isOperator));
>                 return nativeFunctionDeclaration;
>             };
>             if (!program.append(createAnder(AST::AddressSpace::Constant))

Actions: View | Formatted Diff | Diff

Attachments on bug 199462: 373413